多线程案例，单例模式，阻塞队列，定时器
重点：单例模式，阻塞队列，定时器，线程池
多线程案例
- 1.单例模式
-
- 1.1定义
- 1.2实现
-
- 1.2.1饿汉模式
- 1.2.2懒汉模式
- 1.3如何保证懒汉模式线程安全
- 2.阻塞队列
-
- 2.1定义
-
- 2.1.1生产着消费者模型
- 3.Java提供的BlockingQueue
- 4.自己实现阻塞队列
-
- 4.1基于数组（环形队列）
- 4.2基于链表
- 5.定时器
- 5.5 定时器总结
- 6.协程
- 7.线程池（java提供的）
- 8.线程池（自己实现）
1.单例模式
1.1定义
- 是一种设计模式，在代码中有些对象应该只有一个实例，就称为“单例”
- eg：数据库的DataSource应该就是一个单例
- 有些负责加载数据到内存的类也应该是单例
- 强制性某个类只有一个实例
1.2实现
- 主要依托于static关键字，静态成员
1.2.1饿汉模式
/**
* User:yang
*/
public class ThreadDemo16 {
//饿汉模式
//实例创建出现在类加载阶段
static class Singleton {
//希望是单例类，只有一个实例
//县创建一个成员，保存唯一的实例
private static Singleton instanse = new Singleton();
//在提供方法获取实例
public static Singleton getInstance() {
return instanse;
}
//把构造方法私有，防止其他代码创建实例
private Singleton() {
}
}
public static void main(String[] args) {
//如何获取这个实力
Singleton singleton=Singleton.getInstance();
}
}
1.2.2懒汉模式
/**
* User:yang
*/
public class ThreadDemo17 {
//懒汉模式
//创建实例是在第一次使用getinstance的时候，比饿汉模式迟
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.3如何保证懒汉模式线程安全
- 加锁
- 以效率为代价保证安全
/**
* User:yang
*/
public class ThreadDemo18 {
//线程安全版本懒汉模式
//创建实例是在第一次使用getinstance的时候，比饿汉模式迟
static class Singleton {
private static Singleton instance = null;
public static Singleton getInstance() {
synchronized (Singleton.class){
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
private Singleton() {
}
}
public static void main(String[] args) {
Singleton singleton=Singleton.getInstance();
}
}
- 优化，当已经创建实例后，不进入加锁，并且volatile防止寄存器优化
/**
* User:yang
*/
public class ThreadDemo18 {
//线程安全版本懒汉模式
//创建实例是在第一次使用getinstance的时候，比饿汉模式迟
static class Singleton {
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
private Singleton() {
}
}
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
}
}
2.阻塞队列
2.1定义
- 1.这个队列是线程安全的（内部进行了加锁控制）
- 2.当队列满的时候，往里插入元素，此时就会阻塞，一直阻塞到队列不满的时候插入
- 当队列为空的时候，从队列取元素也会阻塞，一直阻塞到队列不为空的时候才完成取元素
- 使用场景：生产着消费者模型
2.1.1生产着消费者模型
- 实例：
- 包饺子
- 擀饺子皮（生产者）
- 包（消费者）
- 在服务器开发中很有用，一个服务器，同一时刻可能受到很多请求，服务器能力有限，可能会挂（削弱峰值）
- 实际上我们会在请求的时候使用阻塞队列，应用程序按照固定节奏从阻塞队列里面获取数据，请求在阻塞队列缓存着，不会消耗太多CPU资源
- 消息队列：也是阻塞队列，但是功能更强大
- 1.里面的数据带有类型topic，按照topic进行分类，把相同的topic的数据放到不同的队伍当中，分别进行排队，
- 一个消息队列，可以同时支撑多个业务的多组数据
- 2.往往是单独的服务器/服务器集群，通过网络通信的方式，进行“生产/消费”
- 3.还支持持久化存储（数据存在磁盘上）
- 4.消费的时候支持多种消费模式
- （1.指定位置消费，（不一定是取出队首元素）
- （2.镜像模式消费（一个数据可以被取多次，不是取一次就直接删除）
3.Java提供的BlockingQueue
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* User:yang
*/
public class ThreadDemo20 {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);
//创建生产者线程
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(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
//消费者线程
Thread customer = new Thread() {
@Override
public void run() {
while (true) {
try {
String elem = queue.take();
Thread.sleep(1000);
System.out.println("customer获取到" + elem);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
try {
producer.join();
customer.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
4.自己实现阻塞队列
4.1基于数组（环形队列）
/**
* User:yang
*/
public class ThreadDemo21 {
//先基于数组的方式实现一个普通队列
//再改进程阻塞队列
static class BlockingQueue {
private int[] items = new int[1000];
//约定[head,tail)是一个前闭后开区间
//初始状态head，tail为0，表示区间为空
//从head取元素
private int head = 0;
//往tail添加元素
private int tail = 0;
//表示元素个数
public int size = 0;
//引入一个“锁对象”
private Object locker = new Object();
//入队列
public void put(int value) throws InterruptedException {
synchronized (locker) {
while (size == items.length) {//wait结束之后，不一定队列不是满的
//队列已经满了,阻塞等待
locker.wait();
}
//队列没有满，插入到tail位置
items[tail] = value;
tail++;
//处理tail超出边界
if (tail >= items.length) {
tail = 0;
}
size++;
locker.notifyAll();
}
}
public Integer take() throws InterruptedException {
int ret = 0;
synchronized (locker) {
//队列为空，阻塞等待
while (size == 0) {
locker.wait();
}
ret = items[head];
head++;
if (head >= items.length) {
head = 0;
}
size--;
locker.notifyAll();
}
return ret;
}
}
public static void main(String[] args) throws InterruptedException {
BlockingQueue queue = new BlockingQueue();
Thread producer = new Thread() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
try {
System.out.println("产生了元素" + i);
queue.put(i);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
Thread customer = new Thread() {
@Override
public void run() {
while (true){
int ret= 0;
try {
ret = queue.take();
System.out.println("消费了元素"+ret);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
producer.join();
customer.join();
}
public static void main1(String[] args) throws InterruptedException {
BlockingQueue queue = new BlockingQueue();
queue.put(1);
queue.put(2);
queue.put(3);
queue.put(4);
System.out.println(queue.take());
System.out.println(queue.take());
System.out.println(queue.take());
System.out.println(queue.take());
System.out.println(queue.take());
}
}
4.2基于链表
5.定时器
- 设置一个任务，约定这个任务在指定时间之后执行
- Timer提供核心及入口，schedule（安排）指定一个任务交给定时器，在一定的时间之后来执行这个任务。
- 1.Timer中要包含一个Task类，每个Task就表示一个具体的任务实例
- Task里面包含一个时间戳（啥时候执行任务），还包含一个Runnable实例（用来表示任务具体是啥）
- 2.Timer里面通过一个带优先级的阻塞队列（时间到了就先执行，快要到时间的任务优先级更高），来组织若干个task
- 3.Timer中还需要一个专门的线程，让这个线程不停的扫描队首元素，看看队首元素是不是可以执行了，如果可以执行了，就执行这个任务，如果不能执行，就继续在队列中等待。
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;
/**
* User:yang
* 一个简单定时器
*/
public class ThreadDemo22 {
//每个Task就表示一个具体的任务实例
//task放入优先队列的时候要比较优先级
static class Task implements Comparable<Task> {
//啥时候执行
private long time;
//执行啥
private Runnable command;
//
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);
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 comand=new Runnable() {
@Override
public void run() {
System.out.println("时间到了");
timer.schedule(this,3000);
}
};
System.out.println("安排任务");
timer.schedule(comand,3000);
}
}
5.5 定时器总结
- 目的：让某个任务在某个时间点再执行，不是立即执行
- 接口：schedule把一个任务和时间加入到定时器中
- 结构：
- （1）Task类，来描述一个任务
- （2）带优先级的阻塞队列
- （3）线程，扫描队首元素
- （4）mailBox防止扫描线程忙等
6.协程
- 比线程更升级
7.线程池（java提供的）
- 把一些线程创建好，用的时候从池子取一个线程，用完了不是销毁，而是放回池子里。
- java提供的
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* User:yang
*/
public class ThreadDemo23 {
public static void main(String[] args) {
//创建包含10个线程的线程池
ExecutorService pool= Executors.newFixedThreadPool(10);
// //创建线程数量动态变化的的线程池
// ExecutorService pool2=Executors.newCachedThreadPool();
int i = 0;
for (; i <100 ; i++) {
int finalI = i;
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello"+ finalI);
}
});
}
}
}
8.线程池（自己实现）
- 线程池内部结构
- 1.描述一个任务（runnable），只需要知道任务做啥，不需要知道任务啥时候执行
- 2.组织很多任务，使用阻塞队列来保存当前的所有任务
- 3.有一些线程，来负责执行阻塞队列中的任务，阻塞队列为空则等待
- 4.还需要list把当前线程保存起来，方便管理
import javafx.concurrent.Worker;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* User:yang
*/
public class ThreadDemo24 {
static class ThreadPool {
//描述一个任务（runnable）
//组织很多任务，使用阻塞队列来保存当前的所有任务
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 maxcount=10;
//核心接口execute
public void execute(Runnable command) throws InterruptedException {
if (workers.size()<maxcount){
//当前池子没有足够的线程，创建新的线程
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 < 10; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
}