线程池、锁策略

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作为任务队列, 容量为1000
        queue = 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() {
            @Override
            public void run() {
                System.out.println("hello 3000");
            }
        }, 3000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello 2000");
            }
        }, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public 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;
    }

    @Override
    public 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) {
                        // 取出队首元素
                        // 这里使用 while
                        while (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() {
            @Override
            public void run() {
                System.out.println("hello 3000");
            }
        }, 3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 2000");
            }
        }, 2000);
        timer.schedule(new Runnable() {
            @Override
            public 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 类，实现了读写锁