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

Posted 2021-10-03 可乐好哇！

tags:

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

操作系统

冯诺依曼体系结构

CPU（中央处理器）：进行算术运算和逻辑判断；执行一些指令；里面的寄存器空间比较小
存储器：存储数据

内存：空间比较小，访问速度快
外存：空间比较大，访问速度慢

输入设备
输出设备

进程

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

进程的管理

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

并行和并发

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

线程

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

进程和线程的关系

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

进程和线程的区别：

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

基础复习

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

多线程创建步骤

创建一个类继承Thread
重写Thread类里面的run方法，在新的run方法中写执行流程
创建子类实例

调用子类的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关键字

两种风格单例模式：

饿汉模式

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();
    }

}

懒汉模式（一般认为懒汉更高效）

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. 阻塞队列可以帮我们完成“生产者消费者模型”

消息队列（功能更强大的阻塞队列）

里面的数据是带有类型的topic，按照topic进行分类，把相同的topic的数据放到不同的队伍中，分别进行排队
往往是单独的服务器/服务器集群，通过网络通信的方式，进行“生产/消费”
还支持持久化存储（数据存在磁盘上）
消费的时候支持多种消费模式
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");
                }
            });
        }
    }
}

在线程池内部如果任务少，都好办，如果任务多，就需要排队，也需要用到阻塞队列

实现线程池

描述一个任务，就是用Runnable，只需要知道任务做啥，不需要知道任务啥时候执行
组织很多任务，使用阻塞队列来保存当前所有任务
有一些线程，来负责执行阻塞队列中的任务，让这些线程从阻塞队列中取任务并执行，如果阻塞队列为空，就等待
需要一个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可以实现一个自旋锁/轻量级锁

创建线程的方式

继承Thread类重写run方法
创建类实现Runnable
使用lambda
创建类的实现Callable

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

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

炸了！又一 VSCode 神器面世（AI 能自动编程了？？）

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

一年的java自学回顾

《计算机网络 PDF》炸了！！！

webbrowser 登录网页

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

操作系统

冯诺依曼体系结构

进程

进程的管理

并行和并发

线程

进程和线程的关系

进程和线程的区别：

基础复习

多线程创建步骤

Thread的属性

启动一个线程（start）

中断一个线程

等待线程

获取线程实例

线程休眠

线程状态

线程安全问题

synchronized（关键字）

volatile（关键字）

对象等待集

wait 和 sleep的对比

单例模式

阻塞队列

消息队列（功能更强大的阻塞队列）

生产者消费者模型

线程池

实现线程池

常见的锁策略

乐观锁

悲观锁

读写锁

重量级锁 和 轻量级锁

公平锁 和 非公平锁

可重入锁 和 不可重入锁

死锁

CAS

创建线程的方式

重量级锁和轻量级锁

公平锁和非公平锁

可重入锁和不可重入锁