操作系统
冯诺依曼体系结构
- 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
- NEW：Thread对象刚创建，还没在系统中创建线程，相当于任务交给线程了，但是线程还没开始执行
- RUNNABLE：线程是一个准备就绪状态，随时可能调度到CPU上执行，或者正在CPU上执行（线程的task struct 在就绪队列中）
- BLOCKED/WAITING/TIMED_WATING：线程当前已经阻塞了
- TERMINATED：线程结束了，Thread对象还没 销毁
线程安全问题
- 由于多个线程访问同一份内存资源，线程是抢占式执行的过程，由于不确定性太多，就可能会导致多个线程同时访问一个资源，这时会出现线程安全问题
- 多线程读，没有线程安全问题
- 多线程写，出现线程安全问题
- 过程：
- 先把内存中的数据读取到CPU中的寄存器中
- 针对寄存器内容，通过一系列指令操作，结构仍放在寄存器中
- 把寄存器中的数据，写回到内存中
- 只有后面的线程load在前一个线程save后面执行，才不会产生线程安全问题
- 解决：
- 线程的抢占式执行过程（操作系统内核实现的）
- 多个线程，修改同一个变量
- 修改操作不是“原子的”（保证操作的原子性是保证线程安全问题的主要手段）
- 内存可见性
- 指令重排序
synchronized（关键字）
- 功能：保证操作的原子性，同时禁止指令重排序和保证内存可见性
- 用法：
- 修饰一个方法
- 修饰一个代码块
- 通过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(); } }
-
-
饿汉模式是线程安全的
-
懒汉模式是线程不安全的
-
线程安全的单例模式：
- 合适的位置加锁（保证if和new都包裹起来，同时范围不要太大）
- 双重if判定（保证需要加锁的时候，一旦初始化完毕，就都是读操作，就不必加锁）
- volatile保证外层if读操作，读到的值都是内存中最新的值
阻塞队列
- 特别好的东西，工作中经常会用到，能够给我们解决很多很多问题
- 队列：先进先出
- 阻塞：
- 这个队列是线程安全的（内部进行了加锁控制）
- 当队列满的时候，往里面插入元素，此时就会阻塞，一直阻塞到队列不满的时候才会完成插入；当队列空的时候，从队列里取元素，此时也会阻塞；一直阻塞到队列不为空的时候才完成取元素
- 阻塞队列可以帮我们完成“生产者消费者模型”
消息队列（功能更强大的阻塞队列）
- 里面的数据是带有类型的topic，按照topic进行分类，把相同的topic的数据放到不同的队伍中，分别进行排队
- 往往是单独的服务器/服务器集群，通过网络通信的方式，进行“生产/消费”
- 还支持持久化存储（数据存在磁盘上）
- 消费的时候支持多种消费模式
- 指定位置消费（不一定知识取出队首元素）
- 镜像模式消费（一个数据可以被取多次，不是去一次就删除）
生产者消费者模型
-
使用生产消费者模型，来进行“削峰”，削弱请求 峰值对服务器的冲击
-
代码段：
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把锁
- 产生死锁的原因：环路等待（核心原因）
- 死锁的解决方案：
- 不要在加锁代码中尝试获取其它锁
- 约定顺序来加锁
CAS
- 比较并交换，是一个原子操作
- 基于CAS可以实现一个自旋锁/轻量级锁
创建线程的方式
- 继承Thread类重写run方法
- 创建类实现Runnable
- 使用lambda
- 创建类的实现Callable
1775
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
