学习内容:
提示:这里可以添加要学的内容
例如:
1、 线程的等待和通知
2、 线程wait()与sleep()的区别
3、 生产者消费者模式
4、 线程池
线程的等待和通知
Object类中的方法
- wait() 让当前线程进入等待状态,直到被通知为止
- wait(long) 让当前线程进入等待状态,同时设置时间;直到被通知为止或时间结束
- notify() 随机通知一个等待线程
- notifyAll() 通知所有的等待线程
wait()和sleep()的区别
- 调用对象不同
wait() 由锁对象调用
sleep() 由线程调用 - 锁使用不同
执行wait后,自动释放锁
执行sleep后,不会释放锁 - 唤醒机制不同
执行wait后,可以被通知唤醒
执行sleep后,只能等待时间结束后,自动唤醒
等待或通知方法必须是锁对象,否则会抛出IllegalMonitorStateException异常
/**
* 通过锁对象将线程等待,经过5秒通知该线程来执行
*/
public class WaitDemo {
public synchronized void print() throws InterruptedException {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--->" +i);
if(i == 50){
//让当前线程等待
this.wait();
}
}
}
public synchronized void notifyTest(){
//让等待的线程执行
this.notifyAll();
}
public static void main(String[] args) {
WaitDemo waitDemo = new WaitDemo();
new Thread(()->{
try {
waitDemo.print();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
waitDemo.notifyTest();
}
}
生产者消费者模式
一种设计模式,不属于GOF23
生产者和消费者
- 生产者
某些程序/进程/线程负责生产数据就属于生产者 - 消费者
某些程序/进程/线程负责使用数据就属于消费者
生产者和消费者之间的问题
- 耦合性高,生产者和消费者联系紧密,不利于系统的扩展和维护
- 并发性能低,同时能处理请求量少
- 忙闲不均,生产者和消费者的速度不一致,带来系统资源的浪费
实现过程:
- 通过添加缓冲区,设置上限
- 生产者生产数据,向缓冲区存放,如果满了,生产者进入等待,直到缓冲区有空的位置通知生产者生产;
- 消费者从缓冲区取数据进行消费,如果空了,消费者进入等待,直到缓冲区有数据再通知消费者消费。
解决问题:
- 解耦
- 提高并发性能
- 解决忙闲不均
package com.hopu.thread;
import java.util.ArrayList;
import java.util.List;
/**
* 包子铺
*/
public class BaoziShop {
/**
* 包子
*/
class Baozi{
private int id;
public Baozi(int id) {
this.id = id;
}
@Override
public String toString() {
return "包子--" + id;
}
}
//上限
public static final int MAX_COUNT = 100;
//缓冲区 存放数据
private List<Baozi> baozis = new ArrayList<>();
/**
* 做包子
*/
public synchronized void makeBaozi() throws InterruptedException {
//判断缓冲区是否满了
if(baozis.size() == MAX_COUNT){
System.out.printf("缓冲区满了,%s等待%n",Thread.currentThread().getName());
//让生产者线程等待
this.wait();
}else{
//通知生产者线程生产
this.notifyAll();
}
//创建包子
Baozi baozi = new Baozi(baozis.size() + 1);
System.out.println(Thread.currentThread().getName()+"做了"+baozi);
//保存到缓冲区
baozis.add(baozi);
}
/**
* 拿包子
*/
public synchronized void takeBaozi() throws InterruptedException {
//判断缓冲区是否空了
if(baozis.size() == 0){
System.out.printf("缓冲区空了,%s等待%n", Thread.currentThread().getName());
//让消费者等待
this.wait();
}else{
//通知消费者消费
this.notifyAll();
}
//获得第一个包子,并删除
if(baozis.size() > 0){
Baozi baozi = baozis.remove(0);
System.out.println(Thread.currentThread().getName()+"吃了"+baozi);
}
}
public static void main(String[] args) {
BaoziShop baoziShop = new BaoziShop();
//一个生产者
Thread productor = new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
baoziShop.makeBaozi();
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
productor.start();
//10个消费者吃10个包子
for (int i = 0; i < 10; i++) {
Thread consumer = new Thread(() ->{
try {
for (int j = 0; j < 10; j++) {
baoziShop.takeBaozi();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
consumer.start();
}
}
}
应用场景:
- 12306售票
- 消息队列
- 线程池
- 等等
阻塞队列
应用了生产者消费者模式的集合,他可以在缓存区满或者空,自动通知线程执行等待和通知,里面有个接口
BlockingQueue 接口
- put 添加数据,达到上限会自动让线程等待
- take 取并删除数据,数据空了会自动让线程等待
实现类
ArrayBlockingQueue 类 数据结构为数组
LinkedBlockingQueue类 链表结构
/**
* 包子铺
*/
public class BaoziShop2 {
/**
* 包子
*/
static class Baozi{
private int id;
public Baozi(int id) {
this.id = id;
}
@Override
public String toString() {
return "包子--" + id;
}
}
public static void main(String[] args) {
//阻塞队列
BlockingQueue<Baozi> baozis = new ArrayBlockingQueue<>(100);
//生产者线程
new Thread(() -> {
for (int i = 0; i < 200; i++) {
//创建包子,添加到阻塞队列,满了就自动阻塞线程
Baozi baozi = new Baozi(baozis.size() + 1);
try {
baozis.put(baozi);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"生产了"+baozi);
}
}).start();
//消费者线程
for(int i = 0;i < 5;i++){
new Thread(() -> {
//取包子,空了会自动阻塞
for (int j = 0; j < 40; j++) {
try {
Baozi baozi = baozis.take();
System.out.println(Thread.currentThread().getName()+"消费了"+baozi);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
线程池
线程池的创建跟类别可以看前面多线程(二)
线程池的优化配置
线程池的实现类
ThreadPoolExecutor
线程池的构造方法参数:
- corePoolSize 核心线程数,创建线程池后自带线程,不会进行销毁
- maximumPoolSize 最大线程数
- keepAliveTime 存活时间,非核心线程能够闲置的时间,超过后被销毁
- timeUnit 时间单位
- blockingQueue 阻塞队列 存放任务(Runnable)的集合
优化配置
-
核心线程数 应该和CPU内核数量相关 CPU内核数 * N (N和任务执行需要时间和并发量相关)
Runtime.getRuntime().availableProcessors()
-
最大线程数可以和核心线程数一样,避免频繁创建和销毁线程
-
如果存在非核心线程,设置大一点,避免频繁创建和销毁线程
-
阻塞队列使用LinkedBlockingQueue,插入和删除任务效率更高
线程池的实现原理
问题:线程池是如何对线程进行回收利用的?
所有线程保存在HashSet中
/**
* Set containing all worker threads in pool. Accessed only when
* holding mainLock.
*/
private final HashSet<Worker> workers = new HashSet<Worker>();