多线程案例之懒汉模式，阻塞队列，定时器，线程池实现
目录
- 单例模式
-
- 懒汉模式
- 饿汉模式
- 阻塞队列
-
- 演示 Java 中阻塞队列
- 模拟实现一个阻塞队列
- 实现定时器（Timer）
- 线程池
-
- 简单使用线程池
- 实现一个线程池
单例模式
懒汉模式
懒汉模式的单例模式 (在调用方法的时候才会创建实例对象），线程安全版的懒汉模式，使用双重 if 提高效率，使用 sychronized 加锁线程安全，volatile 保证内存可见性，外层的 if 读取到的是最新值。
public class ThreadDemo10 {
// 懒汉模式 (在调用方法的时候才会创建实例对象)
static class Singleton {
volatile private Singleton instance = null;
// 构造方式私有,防止其他代码再创建实例
private Singleton () {}
// 双重 if 加 synchronized锁 既保证了线程安全，又保证了效率
public Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
public static void main(String[] args) {
Singleton s = new Singleton();
s.getInstance();
}
}
饿汉模式
饿汉模式的单例模式，实例的创建出现在 “类加载” 阶段，第一次使用到这个类的时候，就会把这个类的 .class 加载到内存里。
public class ThreadDemo9 {
// 饿汉模式 (实例的创建出现在类加载的时候)
static class Singleton {
// 先创建一个成员, 保存唯一的一个 Singleton 实例
private static Singleton instance = new Singleton();
// 然后把类的构造方法设为 private, 防止其他代码再创建实例
private Singleton() {}
// 再提供一个方法, 来获取到这个实例
public static Singleton getInstance () {
return instance;
}
}
public static void main(String[] args) {
// 只能通过 getInstance 的方式获取到该实例.
// 而无法通过 new 的方式创建新的 Singleton 实例了.
Singleton s = Singleton.getInstance();
}
}
阻塞队列
演示 Java 中阻塞队列
队列我们知道是是一种数据结构，一边添加数据，另一边删除数据。阻塞队列就是在队列的基础上实现了类似于 “生产者”，“消费者” 模型，当队列中没有数据的时候，使用 take() 方法取数据就会阻塞(线程等待，不是报错)，知道有数据写入的时候才会取到值。同理，当队列满的时候，我们使用 put() 方法添加数据的时候，也会阻塞，直到阻塞队列中有空间了才会添加成功。Java 中提供了现成接口
BlockingQueue。我们通过实现多个线程来观察效果。
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
// 阻塞队列
public class ThreadDemo11 {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
// 创建生产者模型
Thread producer = new Thread() {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
try {
queue.put(i);
System.out.println("producer 生产数字"+i);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
// 创建消费者模型
Thread customer = new Thread() {
@Override
public void run() {
while (true){
try {
int elem = queue.take();
System.out.println("customer 消费数字"+elem);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
producer.join();
customer.join();
}
}
结果如下图：当设置生产速度和消费速度相同时，那么在队列中就会产生这样的一个效果。
模拟实现一个阻塞队列
// 基于数组实现一个普通的队列
// 改进成阻塞队列
public class ThreadDemo12 {
static class myBlockingQueue {
private int[] elem = new int[100];
// 从头部取元素
private int head = 0;
// 从尾部存元素
private int tail = 0;
// 表示当前队列元素个数
private int size = 0;
// 创建一个锁对象
private Object locker = new Object();
// 入队列
public void put(int value) throws InterruptedException {
synchronized(locker) {
// 队列已经满了,阻塞等待,等待队列不为空的时候,再插入
while (size == elem.length) {
locker.wait();
}
elem[tail] = value;
tail++;
// 处理 tail 超出边界
if (tail >= elem.length) {
tail = 0;
}
size++;
locker.notifyAll();
}
}
// 出队列
public Integer tack() throws InterruptedException {
int value = 0;
// 队列为空的时候, 也要阻塞等待
synchronized (locker) {
if (size == 0) {
locker.wait();
}
value = elem[head];
head++;
if (head >= elem.length) {
head = 0;
}
size--;
locker.notifyAll();
}
return value;
}
}
public static void main(String[] args) throws InterruptedException {
myBlockingQueue queue = new myBlockingQueue();
// 存元素
Thread producer = new Thread() {
@Override
public void run() {
for (int i = 0; i <1000; i++) {
try {
System.out.println("存储了元素: "+i);
queue.put(i);
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
// 取元素
Thread customer = new Thread() {
@Override
public void run() {
while (true) {
try {
int ret = queue.tack();
System.out.println("取出元素: "+ret);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
producer.join();
customer.join();
}
}
运行结束：
实现定时器（Timer）
定时器(Timer)就相当于一个闹钟，给定时器设定一个任务，约定这个任务在XXX时间之后执行。Timer 提供一个核心接口 schedule ，指定一个任务交给定时器，在一定的时间后来执行这个任务。
1. Timer 中要包含一个 Task 类，每一个 Task 就表示一个具体的任务实例。Task 里面包含一个时间戳(表示什么时候去执行这个任务)，还包含一个 Runnable 实例(用来表示任务具体执行的是啥)
2. Timer 里面通过一个带优先级的的阻塞队列，来组织若干个 task。
3. Timer 中还需要一个专门的线程，让这个线程不停的扫描队首元素，看看队首元素是不是可以执行了，如果可以执行，就执行，如果不能执行，就在队列中继续等待
// 定时器
public class ThreadDemo14 {
// 每个 Task 实例包含一个要执行的任务
// Task 要放到优先队列中，但是优先队列里面要进行 ”优先级比较“
static class Task implements Comparable<Task> {
// 啥时候执行
private long time;
// 执行什么
private Runnable command;
// 一般设置定时器的时候,传入的时间,都是一个时间间隔
// 例如写 1000, 意思就是 1000ms 之后再执行
public Task(Runnable command,long time) {
this.command = command;
// 为了后面方便判断,在这里记录一下绝对时间
this.time = System.currentTimeMillis() + time;
}
public void run () {
command.run();
}
@Override
public int compareTo(Task o) {
// 时间小的排到前面
return (int)(this.time - o.time);
}
}
static class Timer {
// 创建一个带优先级的阻塞队列
private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();
// 使用这个对象来完成线程之间的协调任务
private Object mailBox = new Object();
// schedule 方法的功能就是把一个 Task 放到 Timer中
public void schedule(Runnable command,long after) {
Task task = new Task(command,after);
queue.put(task);
// 当 worker 线程中包含 wait 机制的时候,再安排任务的时候就需要显示的唤醒一下了
// 此处是为了处理, 插入的新任务比当前队首的任务还要靠前的情况
synchronized (mailBox) {
mailBox.notify();
}
}
public Timer() {
// 创建一个线程,让这个线程去扫描队列的队首元素,看看能不嫩执行
Thread worker = new Thread() {
@Override
public void run() {
while (true) {
// 取出队首元素,判断一下这个元素能不执行
try {
Task task = queue.take();
long currentTime = System.currentTimeMillis();
if (currentTime >= task.time) {
// 时间到了，执行任务
task.run();
} else {
// 时间没到,继续等待
queue.put(task);
synchronized (mailBox) {
mailBox.wait(task.time - currentTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
worker.start();
}
}
public static void main(String[] args) {
Timer timer = new Timer();
Runnable command = new Runnable() {
@Override
public void run() {
System.out.println("时间到了");
timer.schedule(this,3000);
}
};
System.out.println("安排任务");
timer.schedule(command,3000);
}
}
总结：定时器
目的：让某个任务在某个时间点再执行，不是立刻执行
接口：schedule，把一个任务＋时间加入到定时器中
结构：a) Task类，来描述一个任务。b) 带优先级的阻塞队列。c) 线程扫描队首元素。d) mailBox 方止扫描线程忙等
线程池
简单使用线程池
这个是线程池的一个比较简单的用法。实际上线程池还有更复杂的用法，
标准库里 ThreadPool 类，这个类构造方法中提供了很多的参数选项，来控制线程池具体的行为。
Executors 相当于是对 ThreadPool 进行了简单的封装(把很多参数都给定了默认选项)
工作中更常用的是 ThreadPool 这个复杂版本，就可以更精细的来控制线程池的行为~~
public static void main(String[] args) {
// 创建方式有很多种.
// 比如可以通过 Exectors 的静态方法来负责创建不同类型的线程池.
// 创建一个包含 10 个线程的线程池.
ExecutorService pool = Executors.newFixedThreadPool(10);
// 创建一个线程数量动态变化的线程池
// ExecutorService pool2 = Executors.newCachedThreadPool();
// 创建好了, 就需要往里面放任务.
for (int i = 0; i < 100; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
实现一个线程池
线程池内部要有哪些结构:
1. 描述一个任务，就使用Runnable即可，只需要知道任务做啥，不需要知道任务啥时候执行
2. 组织很多任务，使用阻塞队列来保存当前 的所有任务
3. 有一些线程，来负责执行阻塞队列中的任务，让这些线程从阻塞队列中取任务并执行，如果阻塞队列为空，就等待
4. 还需要有一个List把当前线程都保存起来，方便管理
public class ThreadDemo16 {
static class ThreadPool {
// 1. 使用 Runnable 来描述这个任务,不需要额外的类
// 2. 组织若干个任务,使用阻塞队列来组织
private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
// 3. 描述一个线程,用来进行工作
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();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 4. 把线程组织起来
private List<Worker> workers = new ArrayList<>();
// 设置一个线程最大值
private static final int MAX_WORKERS_COUNT = 10;
// 核心接口
public void execute(Runnable command) throws InterruptedException {
if (workers.size() < MAX_WORKERS_COUNT) {
// 当前池子里没有足够的线程, 就创建个新的线程
Worker worker = new Worker(queue);
worker.start();
workers.add(worker);
}
queue.put(command);
}
}
public static void main(String[] args) throws InterruptedException {
ThreadPool pool = new ThreadPool();
for (int i = 0; i < 100; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
}