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

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数据结构与算法教程 - 熟练操作数组

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