当前位置：首页 > news >正文

线程池、锁策略

news 2025/9/1 5:42:33

线程池

模拟实现线程池

定时器

实现定时器

时间轮

常见的锁策略

乐观锁 vs 悲观锁

重量级锁 vs 轻量级锁

挂起等待锁 vs 自旋锁

普通互斥锁 vs 读写锁

可重入锁 vs 不可重入锁

公平锁 vs 非公平锁

总结

synchronized 原理

基本特点

加锁工作过程

编辑偏向锁

线程池

上古时期，服务器处理多个客户端的请求，是基于多进程的模型。每次有个客户端请求过来了，服务器这边都创建一个进程给这个客户端提供服务（读取请求，解析请求，返回响应…….)。后来，频繁创建销毁进程，效率比较低，所以引入了线程

引入线程后，模型就成了，每个客户端都分配一个线程提供服务。随着客户端数量越来越多，发现频繁创建销毁线程，也变的比较低效了，又引入了线程池

线程池最主要的还是解决服务器开发的问题，假设线程池里提前准备好10个线程，有100个客户端吧请求发过来，把这100个客户端的请求封装成任务（Runnable）添加到线程池里，线程池中由这10个线程负责处理这100个任务，这个过程就不涉及线程的创建销毁了

模拟实现线程池

1. 核心操作为 submit，将任务加入线程池中，任务就是 runnable

2. 使用 Worker 类描述一个工作线程，使用 Runnable 描述一个任务

3. 使用一个 BlockingQueue 组织所有的任务

4. 每个 worker 线程要做的事情：不停的从 BlockingQueue 中取任务并执行

5. 指定一下线程池中的最大线程数 maxWorkerCount；当当前线程数超过这个最大值时，就不再新增线程了

// 实现一个固定线程个数的线程池
class MyThreadPool {private BlockingQueue<Runnable> queue = null;public MyThreadPool(int n) {// 初始化线程池，创建固定个数的线程// 这里使用ArrayBlockingQueue作为任务队列, 容量为1000queue = new ArrayBlockingQueue<>(1000);// 创建 N 个线程for (int i = 0; i < n; i++) {Thread t = new Thread(() -> {try {while (true) {Runnable task = queue.take();task.run();}} catch (InterruptedException e) {e.printStackTrace();}});// t.setDaemon(true); // 设置为后台线程t.start();}}public void submit(Runnable task) throws InterruptedException {// 将任务放入队列中queue.put(task);}
}public class Demo35 {public static void main(String[] args) throws InterruptedException {MyThreadPool pool = new MyThreadPool(10);// 向线程池提交任务for (int i = 0; i < 100; i++) {int id = i;pool.submit(() -> {System.out.println(Thread.currentThread().getName() + " id=" + id);});}}
}

虽然100个任务已经结束了但是进程仍然没有结束，此时线程池里的这些线程，还在 take 阻塞，说明线程池中的线程，是前台线程，会阻止进程结束！

补充知识：

手动停止上述程序，显示的是数字 130，这个数字表示程序的退出码

操作系统中约定了：退出码为 0，表示正常结束；非0表示异常结束（不同的数字表示不同的原因）

正常结束：

定时器

定时器是软件开发中的一个重要组件，类似于一个 “闹钟”，达到一个设定的时间之后，就执行某个指定好的代码

定时器是一种实际开发中非常常用的组件。比如网络通信中，如果对方 500ms 内没有返回数据，则断开连接尝试重连。比如一个Map，希望里面的某个 key 在 3s 之后过期（自动删除）。类似这样的场景就需要用到定时器

标准库中的定时器

标准库中提供了一个 Timer 类，Timer 类的核心方法为 schedule
schedule 包含两个参数，第一个参数指定即将要执行的任务代码，第二个参数指定多长时间之后执行（单位为毫秒）

public class Demo37 {public static void main(String[] args) {Timer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("hello 3000");}}, 3000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("hello 2000");}}, 2000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("hello 1000");}}, 1000);System.out.println("hello main");}
}

1. TimerTask 实现了 Runnable，核心还是重写 run 方法

2. 和线程池一样，Timer中也包含前台线程，会阻止进程结束

实现定时器

1. 创建一个类，表示一个任务

2. 定时器中，要能够管理多个任务，必须使用一些集合类把这多个任务给管理起来。这里使用优先级队列（不要使用 PriorityBlockingQueue，容易死锁）

ArrayList 是否可行呢？

不可行。当管理多个任务的时候，需要确保，时间最早的任务最先执行，ArrayList 要通过遍历的方式，找到时间最早的任务，指定的时间可能不准

3. 实现 schedule 方法。把任务添加到队列中即可

4. 额外创建一个线程，负责执行队列中的任务。和线程池不同，线程池是只要队列不为空，就立即取任务并执行。这里需要看队首元素的时间是否到了，时间到才能执行，时间不到不能执行

// 基于抽象类的方式定义 MyTimerTask 的写法
// 这样的定义虽然确实可以, 但写起来有点麻烦，还有另外的写法
//abstract class MyTimerTask implements Runnable {
//    @Override
//    public abstract void run();
//}class MyTimerTask implements Comparable<MyTimerTask> {private Runnable task;// 记录任务要执行的时刻private long time;public MyTimerTask(Runnable task, long time) {this.task = task;this.time = time;}@Overridepublic int compareTo(MyTimerTask o) {return (int) (this.time - o.time);// return (int) (o.time - this.time);}public long getTime() {return time;}public void run() {task.run();}
}// 自己实现一个定时器
class MyTimer {private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();// 直接使用 this 作为锁对象, 当然也是 ok 的private Object locker = new Object();public void schedule(Runnable task, long delay) {synchronized (locker) {// 以入队列这个时刻作为时间基准.MyTimerTask timerTask = new MyTimerTask(task, System.currentTimeMillis() + delay);queue.offer(timerTask);locker.notify();}}public MyTimer() {// 创建一个线程, 负责执行队列中的任务Thread t = new Thread(() -> {try {while (true) {synchronized (locker) {// 取出队首元素// 这里使用 whilewhile (queue.isEmpty()) {locker.wait();}MyTimerTask task = queue.peek();if (System.currentTimeMillis() < task.getTime()) {// 当前任务时间, 如果比系统时间大, 说明任务执行的时机未到locker.wait(task.getTime() - System.currentTimeMillis());} else {// 时间到了, 执行任务task.run();queue.poll();}}}} catch (InterruptedException e) {e.printStackTrace();}});t.start();}
}public class Demo38 {public static void main(String[] args) {MyTimer timer = new MyTimer();timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("hello 3000");}}, 3000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("hello 2000");}}, 2000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("hello 1000");}}, 1000);// 带有线程池的计时器Executors.newScheduledThreadPool(4);}
}

说明：

1. 优先级队列必须要明确的比较规则。如果元素是数字或 String 这种本身就有明确比较规则的对象，可以不额外指定

2. 调用schedule是一个线程，定时器内部又有一个线程，多个线程操作同一个队列，一定涉及到线程安全问题，需要使用锁

3. 锁加到下图这个位置，可能会因为 synchronized 阻塞，使得时间存在一点误差，所以建议把 timeTask 也放到锁里

4. 标准库提供的 Timer 和自己实现的 MyTimer 差不多，都是使用一个线程，负责扫描队首元素并执行的。如果任务少或任务的时间分散问题不大，如果任务特别多，时间非常集中一个线程就可能执行不过来。更好的做法是一个线程负责扫描，扫描到需要执行的任务，添加到另一个线程池的任务队列中，由多个线程负责执行

5. 标准库中带有线程池的计时器：Executors.newScheduledThreadPool();

时间轮

除了基于堆（优先级队列）的方式来实现的定时器之外，还有一种方案，基于 “时间轮”

时间轮类似循环队列（数组），每个元素是一个 “时间单位”，每个元素又是一个链表。每到一个时间单位，光标指向下一个元素，同时把这个元素上对应链表中的任务都执行一遍

优势：性能更高（优先级队列有堆调整的开销)

劣势：时间精度不如优先级队列

时间轮更适合任务特别多的情况

优先级队列更适合精度高的情况

由于定时器，是一个非常重要的组件，以至于在分布式系统中，会把定时器专门提取出来，封装成一个单独的服务器（和消息队列很像）

常见的锁策略

如果你认为标准库提供的锁不够用，想自己实现一把锁，这时需要关注锁策略（其实 synchronized 已经非常好用了，足矣覆盖绝大多数的使用场景）

“锁策略” 不是和Java强相关的。其他语言，但凡涉及到并发编程，涉及到锁，都可以谈到锁策略

锁策略，就是锁在加锁时特点和行为

乐观锁 vs 悲观锁

描述的是加锁时遇到的场景

悲观锁：加锁的时候，预测接下来的锁竞争的情况非常激烈，就需要针对这样的激烈情况额外做一些工作

有一把锁，有二十个线程尝试获取锁，每个线程加锁的频率都很高。一个线程加锁的时候，很可能锁被另一个线程占用着。这种情况用悲观锁的方式处理

乐观锁：加锁的时候，预测接下来的锁竞争的情况不激烈，不需要做额外工作

有一把锁，假设只有两个线程尝试获取这个锁。每个线程加锁的频率都很低，一个线程加锁的时候，大概率另一个线程没有和他竞争。这种情况用乐观锁的方式处理

重量级锁 vs 轻量级锁

遇到场景之后的解决方案

重量级锁，在悲观的场景下，就要付出更多的代价（更低效）

轻量级锁，应对乐观的场景，付出的代价就会更小（更高效）

挂起等待锁 vs 自旋锁

自旋锁：轻量级锁的典型实现

是应用程序级别的。加锁的时候发现有竞争，一般不是进入阻塞，而是通过忙等的形式进行等待

忙等：连续测试一个变量直到某个值出现为止，称为忙等。忙了很长时间，又没有实质性的产出，还持续占着 CPU 而不释放，这个时候应该释放 CPU 让给其他进程

^

在乐观锁的场景下，遇到锁竞争的概率很小，就算遇到竞争，也能在短时间内就能拿到锁，获取锁的周期很短，所以使用忙等的方式影响不大

挂起等待锁：重量级锁的典型实现

是操作系统内核级别的。加锁的时候发现有竞争，就会使该线程进入阻塞状态，后续由内核进行唤醒

获取锁的周期更长，很难做到及时获取，所以这个过程就不必使用忙等的方式一直消耗 cpu 了，把 cpu 省出来做别的事情

synchronized 是悲观 / 乐观呢?

答：既是悲观又是乐观，可以自适应。

VM内部会统计每个锁竞争的激烈程度，如果竞争不激烈，synchronized 就会按照轻量级锁（自旋），如果竞争激烈，synchronized 就会按照重量级锁（挂起等待）

普通互斥锁 vs 读写锁

普通互斥锁：synchronized；只有加锁、解锁两个操作

读写锁：有两种加锁方式：读方式加锁、写方式加锁

1. 多个线程读取一个数据，本身就是线程安全的。多个线程读取，一个线程修改，肯定会涉及到线程安全问题。如果大部分操作在读，少数操作在写，把读和写都加普通的互斥锁，锁冲突非常严重，所以就引入了读写锁

2. 读写锁可以确保，读锁和读锁之间不是互斥的（不会产生阻塞），写锁和读锁之间，才会产生互斥，写锁和写锁之间，也有互斥。

3. 读写锁保证线程安全的前提下，降低锁冲突的概率，提高效率

4. 读写锁适合读多，写少的情况，这种情况在服务器开发中很常见

Java 标准库提供了 ReentrantReadWriteLock 类，实现了读写锁