回顾操作系统,我脑子炸了

Posted 可乐好哇!

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了回顾操作系统,我脑子炸了相关的知识,希望对你有一定的参考价值。

操作系统

冯诺依曼体系结构

  • CPU(中央处理器):进行算术运算和逻辑判断;执行一些指令;里面的寄存器空间比较小
  • 存储器:存储数据
  1. 内存:空间比较小,访问速度快
  2. 外存:空间比较大,访问速度慢
  • 输入设备
  • 输出设备

进程

  • 进程(process):有的系统上,进程叫做“任务”(task),体现的是“完成某个工作的过程”
  • 双击运行程序时,操作系统就会创建一个对应的进程(正在执行任务的过程)

进程的管理

  1. 描述:task struct结构(把这个东西想象成是一个class,实际上操作系统内核是C语言写的,C中没有class这个概念,但是有一个弱化版本的struct)
  2. 组织:使用双向链表把很多的task struct 变量给串起来
  3. 当创建一个进程,本质上就是创建一个task struct放到双向链表中,当有某个进程结束了,本质上就是从这个双向链表上删除该节点
    • pid:进程ID
    • 进程的内存指针:描述进程持有的内存资源是哪些范围(进程依赖的代码,和数据在哪里)
    • 进程的优先级(进程调度)
    • 进程的上下文(进程调度)
    • 进程的记账信息(进程调度)
    • 进程的状态(进程调度)
  4. 进程调度其实是一个“抢占式”执行的进程

并行和并发

  • 并行:从微观角度讲,每个进程和进程之间,是同时执行的
  • 并发:从微观角度讲,进程是串行执行的,从宏观角度讲,进程是“同时”执行的

线程

  • 进程是为了实现并发编程的效果,但是为了追求更高的效率就引入了线程,创建一个进程/销毁一个进程,开销比较大(进程管理着一些系统分配的资源,申请/释放这些资源不是一个简单的事情)
  • 线程被称为“轻量级进程”,每个线程就对应到一个“独立的执行流”,在这个执行流里就能完成一系列的指令,多个线程就有多个“执行流”就可以并发的完成多个系列的指令了

进程和线程的关系

  • 一个进程包含了多个线程
  • 一个进程从系统里申请了很多系统资源,进程统一对这些资源进行管理,这个进程内的多个线程,共享这些资源
  • 进程具有独立性,一个进程挂了,不会影响其他进程
  • 线程是一个生产线坏了,可能会影响整个进程的工作

进程和线程的区别:

  • 进程包含线程,一个进程可以包含一个线程,也可以包含多个线程
  • 进程是资源分配的基本单位,线程是系统调度执行的基本单位
  • 进程和进程之间,是相互独立的,进程1挂了,不影响进程2,同一个进程下的若干个线程,共享这些内存资源;如果某个线程出现异常,可能会导致整个进程终止,因此其他线程也无法工作

基础复习

  • new xxx() 这个对象存在堆上
  • 在方法里创建的局部变量在栈上
  • 静态成员,类的字节码,在方法区上

多线程创建步骤

  1. 创建一个类继承Thread

  2. 重写Thread类里面的run方法,在新的run方法中写执行流程

  3. 创建子类实例

  4. 调用子类的start方法

    class MyThread extends Thread 
        @Override
        public void run() 
            while (true) 
                try 
                    System.out.println("新线程");
                    Thread.sleep(1000);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        
    
    
    public class MultiThreading 
    
        public static void main(String[] args) 
    
            System.out.println("hello");
    
            MyThread myThread = new MyThread();
            myThread.start();
    
            while (true) 
                try 
                    System.out.println("主线程");
                    Thread.sleep(1000);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        
    
    

Thread的属性

  • id
  • name
  • state
  • priority
  • daemon
  • alive
  • isInterrupted

启动一个线程(start)

中断一个线程

  • 让线程的入口方法执行完毕

等待线程

  • 控制线程结束先后顺序 join

获取线程实例

  • Thread.currentThread()

线程休眠

  • Sleep 本质上是把线程的task struct 放到一个等待队列中

线程状态

  • 状态反应的是当前线程正在干啥,对我们调度多线程程序是比较有帮助的
  • Thread.State
    1. NEW:Thread对象刚创建,还没在系统中创建线程,相当于任务交给线程了,但是线程还没开始执行
    2. RUNNABLE:线程是一个准备就绪状态,随时可能调度到CPU上执行,或者正在CPU上执行(线程的task struct 在就绪队列中)
    3. BLOCKED/WAITING/TIMED_WATING:线程当前已经阻塞了
    4. TERMINATED:线程结束了,Thread对象还没 销毁

线程安全问题

  • 由于多个线程访问同一份内存资源,线程是抢占式执行的过程,由于不确定性太多,就可能会导致多个线程同时访问一个资源,这时会出现线程安全问题
  • 多线程读,没有线程安全问题
  • 多线程写,出现线程安全问题
  • 过程:
    1. 先把内存中的数据读取到CPU中的寄存器中
    2. 针对寄存器内容,通过一系列指令操作,结构仍放在寄存器中
    3. 把寄存器中的数据,写回到内存中
  • 只有后面的线程load在前一个线程save后面执行,才不会产生线程安全问题
  • 解决:
    1. 线程的抢占式执行过程(操作系统内核实现的)
    2. 多个线程,修改同一个变量
    3. 修改操作不是“原子的”(保证操作的原子性是保证线程安全问题的主要手段)
    4. 内存可见性
    5. 指令重排序

synchronized(关键字)

  • 功能:保证操作的原子性,同时禁止指令重排序和保证内存可见性
  • 用法:
    1. 修饰一个方法
    2. 修饰一个代码块
  • 通过LOCK 和 UNLOCK 把 load add save打包整一个原子操作
  • 不好之处:程序的运行效率大大降低了

volatile(关键字)

  • 辅助保证线程安全
  • 能够禁止指令重排序,保证内存可见性,但是不保证原子性
  • 主要用于读写同一个变量的时候

对象等待集

  • 协调多个线程之间执行的先后顺序
  • join保证两个线程按照一定的顺序进行
  • wait/notify方法必须要在synchronized中使用,否则直接使用,会产生异常
  • notify通知某个线程被唤醒,从wait中醒来
  • notifyAll 唤醒所有线程(不常用)

wait 和 sleep的对比

  • wait需要请求锁,执行时会先释放锁
  • sleep 是无视锁的存在,即之前请求的锁不会释放,没锁也不会请求
  • wait是Object的方法
  • sleep是Thread的静态方法

单例模式

  • 一种设计模式,针对一些特定的场景(数据库的DataSource就是一个单例)

  • 主要依托于static关键字

  • 两种风格单例模式:

    1. 饿汉模式

      public class MultiThreading8 
          /*
              饿汉模式
           */
          static class Singleton 
              private static Singleton instance = new Singleton();
      
              public static Singleton getInstance() 
                  return instance;
              
      
              private Singleton() 
              
          
      
          public static void main(String[] args) 
              Singleton singleton = Singleton.getInstance();
          
      
      
      
    2. 懒汉模式(一般认为懒汉更高效)

      public class MultiThreading9 
          /*
              懒汉模式
           */
          static class Singleton 
              private static Singleton instance = null;
      
              public static Singleton getInstance() 
                  if (instance == null) 
                      instance = new Singleton();
                  
                  return instance;
              
      
              private Singleton() 
              
          
      
          public static void main(String[] args) 
              Singleton singleton = Singleton.getInstance();
          
      
       
      
  • 饿汉模式是线程安全的

  • 懒汉模式是线程不安全的

  • 线程安全的单例模式:

    1. 合适的位置加锁(保证if和new都包裹起来,同时范围不要太大)
    2. 双重if判定(保证需要加锁的时候,一旦初始化完毕,就都是读操作,就不必加锁)
    3. volatile保证外层if读操作,读到的值都是内存中最新的值

阻塞队列

  • 特别好的东西,工作中经常会用到,能够给我们解决很多很多问题
  • 队列:先进先出
  • 阻塞:
    1. 这个队列是线程安全的(内部进行了加锁控制)
    2. 当队列满的时候,往里面插入元素,此时就会阻塞,一直阻塞到队列不满的时候才会完成插入;当队列空的时候,从队列里取元素,此时也会阻塞;一直阻塞到队列不为空的时候才完成取元素
    3. 阻塞队列可以帮我们完成“生产者消费者模型”

消息队列(功能更强大的阻塞队列)

  1. 里面的数据是带有类型的topic,按照topic进行分类,把相同的topic的数据放到不同的队伍中,分别进行排队
  2. 往往是单独的服务器/服务器集群,通过网络通信的方式,进行“生产/消费”
  3. 还支持持久化存储(数据存在磁盘上)
  4. 消费的时候支持多种消费模式
    1. 指定位置消费(不一定知识取出队首元素)
    2. 镜像模式消费(一个数据可以被取多次,不是去一次就删除)

生产者消费者模型

  • 使用生产消费者模型,来进行“削峰”,削弱请求 峰值对服务器的冲击

  • 代码段:

    public class MultiThreading12 
    
        /**
         * @param 创建生产者消费者模型
         * @throws InterruptedException
         */
        public static void main(String[] args) throws InterruptedException 
    
            BlockingQueue<String> queue = new LinkedBlockingQueue<>();
    
            // 创建生产者线程
            Thread producer = new Thread() 
                @Override
                public void run() 
                    for (int i = 0; i < 10000; i++) 
                        try 
                            System.out.println("producer 生产 str" + i);
                            queue.put("str" + i);
                            Thread.sleep(2000);
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                
            ;
    
            producer.start();
    
            Thread customer = new Thread() 
                @Override
                public void run() 
                    while (true) 
                        try 
                            String str = queue.take();
                            System.out.println("customer获取到" + str);
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                
            ;
    
            customer.start();
    
            producer.join();
            customer.join();
    
        
    
    
    

线程池

  • 把一些线程提前创建好,用的时候从池子里取一个线程就用,用完了不是销毁线程,而是放回池子里

  • 代码片段:

    public class MultiThreading13 
    
        public static void main(String[] args) 
            // 创建一个包含10个线程的线程池
            ExecutorService pool = Executors.newFixedThreadPool(10);
            // 创建动态变化的线程池
            //ExecutorService pool2 = Executors.newCachedThreadPool();
    
            for (int i = 0; i < 10; i++) 
                pool.execute(new Runnable() 
                    @Override
                    public void run() 
                        System.out.println("hello");
                    
                );
            
        
    
    
    • 在线程池内部如果任务少,都好办,如果任务多,就需要排队,也需要用到阻塞队列

实现线程池

  1. 描述一个任务,就是用Runnable,只需要知道任务做啥,不需要知道任务啥时候执行
  2. 组织很多任务,使用阻塞队列来保存当前所有任务
  3. 有一些线程,来负责执行阻塞队列中的任务,让这些线程从阻塞队列中取任务并执行,如果阻塞队列为空,就等待
  4. 需要一个List把当前线程都保存起来,方便管理
 static class ThreadPool 
        private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

        static class Worker extends Thread 

            private BlockingQueue<Runnable> queue = null;

            public Worker(BlockingQueue<Runnable> queue) 
                this.queue = queue;
            

            @Override
            public void run() 
                while (true) 
                    try 

                        Runnable runnable = queue.take();
                        runnable.run();

                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                
            

            private List<Worker> workers = new ArrayList<>();

            private static final int MAX_WORKERS_COUNT = 10;

            public void excute(Runnable command) 
                try 

                    if (workers.size() < MAX_WORKERS_COUNT) 
                        Worker worker = new Worker(queue);
                        worker.start();
                        workers.add(worker);
                    

                    queue.put(command);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            

        
    

常见的锁策略

乐观锁

  • 锁竞争概率比较低(当前场景线程数目比较少,不太涉及竞争,就偶尔竞争一下)

悲观锁

  • 锁竞争概率比较高(当前场景线程数目比较多,可能涉及竞争)
  • 操作系统提供锁接口,认为竞争很大,一旦出现锁竞争,就会让竞争失败的线程进行等待,什么时候唤醒,就得看调度器的实现
  • CAS锁 不涉及内核和操作系统,也就更高效

读写锁

  • 普通锁提供两个操作:加锁,解锁
  • 读写锁提供两个操作:读加锁,写加锁,解锁(进一步降低所冲突的概率)
    • 读读不互斥
    • 写写互斥
    • 读写互斥
  • 主要应用场景:少写多读

重量级锁 和 轻量级锁

  • 重量级锁工作量多,消耗的资源越多,锁更慢
  • 轻量级锁工作量少,消耗的资源越少,锁更快
  • 追女朋友用轻量级锁CAS,死缠烂打

公平锁 和 非公平锁

  • 先来后到,有序排队公平,有人插队不公平的意思

可重入锁 和 不可重入锁

  • synchronized是可重入锁
  • 不可重入锁会导致死锁的问题

死锁

  • 产生死锁,意味着线程挂了,无法继续下面工作
  • 死锁典型场景:
    • 一个线程一把锁
    • 两个线程两把锁
    • N个线程M把锁
  • 产生死锁的原因:环路等待(核心原因)
  • 死锁的解决方案:
    1. 不要在加锁代码中尝试获取其它锁
    2. 约定顺序来加锁

CAS

  • 比较并交换,是一个原子操作
  • 基于CAS可以实现一个自旋锁/轻量级锁

创建线程的方式

  1. 继承Thread类重写run方法
  2. 创建类实现Runnable
  3. 使用lambda
  4. 创建类的实现Callable

以上是关于回顾操作系统,我脑子炸了的主要内容,如果未能解决你的问题,请参考以下文章

回顾操作系统,我脑子炸了

怎样优化系统呀!!!!天呀头的快炸了~~``

省脑子的Javascript数据结构与算法教程 - 熟练操作数组

省脑子的Javascript数据结构与算法教程 - 熟练操作数组

省脑子的Javascript数据结构与算法教程 - 熟练操作数组

刚入职没多久,连夜手写了一个代码生成器,项目开发速度瞬间屌炸了!