并行与并发
并行
在同一时刻,有多个指令在多个CPU上同时执行
并发
在同一时刻,有多个指令在单个CPU上交替执行
线程与进程
操作系统
操作系统是多进程容器
进程
进程是多线程的容器
线程是进程中的单个顺序控制流,是一条执行路径
单线程程序
一个进程如果只有一条执行路径,则称为单线程程序
多线程程序
一个进程如果有多条执行路径,则称为多线程程序
多线程的创建方式
方式一:继承Thread类
Java是通过java.lang.Thread类代表线程
按照面向对象的思想,Thread类提供了实现多线程的方式,所有的线程对象都必须是Thread类或其子类的实例
每个线程的作用是执行一段程序流,即一段顺序执行的代码
方式:
1.定义一个子类MyThread继承(extends)Thread类
2.重写run()方法
3.创建MyTread类的对象
4.对象.start();,启动线程
例:
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.run();
}
}
优点:
编码简单
缺点:
扩展性差,Java只能继承一个父类
1.为什么不直接调用了run方法,而是调用start启动线程?
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行
只有调用start方法才是启动一个新的线程执行
2.把主线程任务放在子线程之前了。
这样主线程一直是先跑完的,相当于是一个单线程的效果
总结
1.线程对象调用start方法,start方法通知JVM为当前线程对象开辟新的方法栈执行空间, 执行当前线程对象的run方法
2.每个线程的run方法执行空间属于线程私有
3.某一个线程运行中出现异常,不会影响其它线程的执行(不考虑同步: 锁的问题)
方式二: 实现Runnable接口
方式:
1.定义一个类MyRunnable实现(implements)Runnable接口
2.在MyRunnable类中重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象,把MyRunnable对象作为构造器的形参
5.Thread类的对象.start();,启动线程
Thread的构造器
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编程多一层对象包装,如果线程有执行结果是不可以直接返回的
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
方式二:实现Runnable接口(匿名内部类)
方式:
1.可以创建Runnable的匿名内部类对象
2.交给Tread处理
3.调用线程对象.start();,启动线程
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
});
}
}
1.Thread类实现多线程与实现Runnable实现多线程的区别?
如果一个类继承Thread,则不适合资源共享,但是如果实现了Runable接口的话,则很容易的实现资源共享
2.实现Runnable接口比继承Thread类所具有的优势:
适合多个相同的程序代码的线程去共享同一个资源
可以避免java中的单继承的局限性
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
方式三:利用Callable,FutureTask接口实现
方式:
1.得到任务对象
1.1定义实现Callable,重写call方法,封装要做的事情
1.2用FutureTask把Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start();,启动线程,执行任务
4.线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编码复杂一点
FutureTask的API
对比三种方式
Thread类获取和修改线程名字
Thread类的API
也可以通过让自定义类调用Thread类的有参构造器,在创建对象时可以赋值
获取到当前的线程对象的方法
某些情况下,非Thread类子类对象没办法调用getName方法获取名称,我们可以通过此方法获取当前正在执行的线程对象再获取名字
Thread类的线程休眠方法
线程安全
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题
多个线程 同时操作 同一个共享资源
线程安全问题出现的原因:
存在多线程并发
同时访问共享资源
存在修改共享资源
线程同步
方式一:同步代码块
锁多条语句操作共享数据,可以使用同步代码块实现
作用:
把出现线程安全的问题的核心代码给上锁
原理:
每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
格式:
synchronized(任意对象){
多条语句操作共享
}
优点:
解决了多线程的数据安全问题
缺点:
当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
1.锁对象用任意唯一的对象好不好呢?
不好,会影响其他无关线程的执行
2.锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
方式二:同步方法
作用:
把出现线程安全问题的核心方法给上锁
原理:
每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
格式:
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理:
同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象
1.是同步代码块好还是同步方法好一点?
同步代码块锁的范围更小,同步方法锁的范围更大
方式三:Lock锁
java.util.concurrent.locks.ReentrantLock
为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象
ReentrantLock实现Lock接口
Lock的API
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private int a = 100;
public Lock lockObj = new ReentrantLock();
@Override
public void run() {
System.out.println("子类线程创建成功");
while (true) {
lockObj.lock();
a+=100;
try {
Thread.sleep(1);
String name = Thread.currentThread().getName();
System.out.println(name+"::"+a);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lockObj.unlock();
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
死锁
死锁是指:
两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
若无外力作用,它们都将无法推进下去
线程状态介绍
生产者与消费者
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者
线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public void xiaoFei() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
}
//被生产者线程调用,表示生产一个包子
public void shengChan() {
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Producer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == true) {
//有包子,生产者线程等待
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//没有包子
//生产一个包子
bz.shengChan();
//修改标记
bz.setFlag(true);
//唤醒消费者
bz.notify();//bz是锁对象
}
}
}
}
public class Consumer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Consumer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == false) {
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//有包子
//消费一个包子
bz.xiaoFei();
//修改标记
bz.setFlag(false);
bz.notify();//bz是锁对象
}
}
}
}
public class Demo03PC {
public static void main(String[] args) {
//创建线程共享资源包子类的对象
BaoZi03 bz = new BaoZi03();
//5.创建生产者线程任务对象
Producer03 pTask = new Producer03(bz);
//5.创建消费者线程任务对象
Consumer03 cTask = new Consumer03(bz);
//6.创建生产者线程对象,构造方法传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,构造方法传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象调用start方法,开启线程进行生产
pThread.start();
//9.消费者线程对象调用start方法,开启线程进行消费
cThread.start();
}
}
优化代码
public class BaoZi04 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public synchronized void xiaoFei() {
if (flag == false) {
//没有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
//修改标记
flag = false;
//唤醒生产者线程
notify();
}
//被生产者线程调用,表示生产一个包子
public synchronized void shengChan() {
if(flag == true) {
//有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
//没有包子,生产一个包子
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
//修改标记
flag = true;
//唤醒消费者线程
notify();
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Producer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.shengChan();//生产一个包子
}
}
public class Consumer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Consumer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.xiaoFei();//消费一个包子
}
}
//测试类
public class Demo04PC {
public static void main(String[] args) {
//创建多线程共享数据资源baoZi类的对象
BaoZi04 bz = new BaoZi04();
//4.创建生产者线程任务对象
Producer04 pTask = new Producer04(bz);
//6.创建消费者线程任务对象
Consumer04 cTask = new Consumer04(bz);
//6.创建生产者线程对象,传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象和消费者线程对象分别调用start方法开启线程
pThread.start();
cThread.start();
}
}
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
在同一时刻,有多个指令在多个CPU上同时执行
并发在同一时刻,有多个指令在单个CPU上交替执行
操作系统操作系统是多进程容器
进程进程是多线程的容器
线程是进程中的单个顺序控制流,是一条执行路径
单线程程序一个进程如果只有一条执行路径,则称为单线程程序
多线程程序一个进程如果有多条执行路径,则称为多线程程序
多线程的创建方式
方式一:继承Thread类
Java是通过java.lang.Thread类代表线程
按照面向对象的思想,Thread类提供了实现多线程的方式,所有的线程对象都必须是Thread类或其子类的实例
每个线程的作用是执行一段程序流,即一段顺序执行的代码
方式:
1.定义一个子类MyThread继承(extends)Thread类
2.重写run()方法
3.创建MyTread类的对象
4.对象.start();,启动线程
例:
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.run();
}
}
优点:
编码简单
缺点:
扩展性差,Java只能继承一个父类
1.为什么不直接调用了run方法,而是调用start启动线程?
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行
只有调用start方法才是启动一个新的线程执行
2.把主线程任务放在子线程之前了。
这样主线程一直是先跑完的,相当于是一个单线程的效果
总结
1.线程对象调用start方法,start方法通知JVM为当前线程对象开辟新的方法栈执行空间, 执行当前线程对象的run方法
2.每个线程的run方法执行空间属于线程私有
3.某一个线程运行中出现异常,不会影响其它线程的执行(不考虑同步: 锁的问题)
方式二: 实现Runnable接口
方式:
1.定义一个类MyRunnable实现(implements)Runnable接口
2.在MyRunnable类中重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象,把MyRunnable对象作为构造器的形参
5.Thread类的对象.start();,启动线程
Thread的构造器
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编程多一层对象包装,如果线程有执行结果是不可以直接返回的
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
方式二:实现Runnable接口(匿名内部类)
方式:
1.可以创建Runnable的匿名内部类对象
2.交给Tread处理
3.调用线程对象.start();,启动线程
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
});
}
}
1.Thread类实现多线程与实现Runnable实现多线程的区别?
如果一个类继承Thread,则不适合资源共享,但是如果实现了Runable接口的话,则很容易的实现资源共享
2.实现Runnable接口比继承Thread类所具有的优势:
适合多个相同的程序代码的线程去共享同一个资源
可以避免java中的单继承的局限性
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
方式三:利用Callable,FutureTask接口实现
方式:
1.得到任务对象
1.1定义实现Callable,重写call方法,封装要做的事情
1.2用FutureTask把Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start();,启动线程,执行任务
4.线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编码复杂一点
FutureTask的API
对比三种方式
Thread类获取和修改线程名字
Thread类的API
也可以通过让自定义类调用Thread类的有参构造器,在创建对象时可以赋值
获取到当前的线程对象的方法
某些情况下,非Thread类子类对象没办法调用getName方法获取名称,我们可以通过此方法获取当前正在执行的线程对象再获取名字
Thread类的线程休眠方法
线程安全
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题
多个线程 同时操作 同一个共享资源
线程安全问题出现的原因:
存在多线程并发
同时访问共享资源
存在修改共享资源
线程同步
方式一:同步代码块
锁多条语句操作共享数据,可以使用同步代码块实现
作用:
把出现线程安全的问题的核心代码给上锁
原理:
每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
格式:
synchronized(任意对象){
多条语句操作共享
}
优点:
解决了多线程的数据安全问题
缺点:
当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
1.锁对象用任意唯一的对象好不好呢?
不好,会影响其他无关线程的执行
2.锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
方式二:同步方法
作用:
把出现线程安全问题的核心方法给上锁
原理:
每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
格式:
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理:
同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象
1.是同步代码块好还是同步方法好一点?
同步代码块锁的范围更小,同步方法锁的范围更大
方式三:Lock锁
java.util.concurrent.locks.ReentrantLock
为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象
ReentrantLock实现Lock接口
Lock的API
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private int a = 100;
public Lock lockObj = new ReentrantLock();
@Override
public void run() {
System.out.println("子类线程创建成功");
while (true) {
lockObj.lock();
a+=100;
try {
Thread.sleep(1);
String name = Thread.currentThread().getName();
System.out.println(name+"::"+a);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lockObj.unlock();
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
死锁
死锁是指:
两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
若无外力作用,它们都将无法推进下去
线程状态介绍
生产者与消费者
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者
线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public void xiaoFei() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
}
//被生产者线程调用,表示生产一个包子
public void shengChan() {
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Producer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == true) {
//有包子,生产者线程等待
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//没有包子
//生产一个包子
bz.shengChan();
//修改标记
bz.setFlag(true);
//唤醒消费者
bz.notify();//bz是锁对象
}
}
}
}
public class Consumer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Consumer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == false) {
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//有包子
//消费一个包子
bz.xiaoFei();
//修改标记
bz.setFlag(false);
bz.notify();//bz是锁对象
}
}
}
}
public class Demo03PC {
public static void main(String[] args) {
//创建线程共享资源包子类的对象
BaoZi03 bz = new BaoZi03();
//5.创建生产者线程任务对象
Producer03 pTask = new Producer03(bz);
//5.创建消费者线程任务对象
Consumer03 cTask = new Consumer03(bz);
//6.创建生产者线程对象,构造方法传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,构造方法传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象调用start方法,开启线程进行生产
pThread.start();
//9.消费者线程对象调用start方法,开启线程进行消费
cThread.start();
}
}
优化代码
public class BaoZi04 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public synchronized void xiaoFei() {
if (flag == false) {
//没有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
//修改标记
flag = false;
//唤醒生产者线程
notify();
}
//被生产者线程调用,表示生产一个包子
public synchronized void shengChan() {
if(flag == true) {
//有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
//没有包子,生产一个包子
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
//修改标记
flag = true;
//唤醒消费者线程
notify();
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Producer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.shengChan();//生产一个包子
}
}
public class Consumer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Consumer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.xiaoFei();//消费一个包子
}
}
//测试类
public class Demo04PC {
public static void main(String[] args) {
//创建多线程共享数据资源baoZi类的对象
BaoZi04 bz = new BaoZi04();
//4.创建生产者线程任务对象
Producer04 pTask = new Producer04(bz);
//6.创建消费者线程任务对象
Consumer04 cTask = new Consumer04(bz);
//6.创建生产者线程对象,传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象和消费者线程对象分别调用start方法开启线程
pThread.start();
cThread.start();
}
}
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
Java是通过java.lang.Thread类代表线程
按照面向对象的思想,Thread类提供了实现多线程的方式,所有的线程对象都必须是Thread类或其子类的实例
每个线程的作用是执行一段程序流,即一段顺序执行的代码
方式:
1.定义一个子类MyThread继承(extends)Thread类
2.重写run()方法
3.创建MyTread类的对象
4.对象.start();,启动线程
例:
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.run();
}
}
优点:
编码简单
缺点:
扩展性差,Java只能继承一个父类
1.为什么不直接调用了run方法,而是调用start启动线程?
直接调用run方法会当成普通方法执行,此时相当于还是单线程执行
只有调用start方法才是启动一个新的线程执行
2.把主线程任务放在子线程之前了。
这样主线程一直是先跑完的,相当于是一个单线程的效果
总结
1.线程对象调用start方法,start方法通知JVM为当前线程对象开辟新的方法栈执行空间, 执行当前线程对象的run方法
2.每个线程的run方法执行空间属于线程私有
3.某一个线程运行中出现异常,不会影响其它线程的执行(不考虑同步: 锁的问题)
方式:
1.定义一个类MyRunnable实现(implements)Runnable接口
2.在MyRunnable类中重写run()方法
3.创建MyRunnable类的对象
4.创建Thread类的对象,把MyRunnable对象作为构造器的形参
5.Thread类的对象.start();,启动线程
Thread的构造器
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编程多一层对象包装,如果线程有执行结果是不可以直接返回的
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
方式二:实现Runnable接口(匿名内部类)
方式:
1.可以创建Runnable的匿名内部类对象
2.交给Tread处理
3.调用线程对象.start();,启动线程
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("子线程创建完毕");
}
});
}
}
1.Thread类实现多线程与实现Runnable实现多线程的区别?
如果一个类继承Thread,则不适合资源共享,但是如果实现了Runable接口的话,则很容易的实现资源共享
2.实现Runnable接口比继承Thread类所具有的优势:
适合多个相同的程序代码的线程去共享同一个资源
可以避免java中的单继承的局限性
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
方式:
1.得到任务对象
1.1定义实现Callable,重写call方法,封装要做的事情
1.2用FutureTask把Callable对象封装成线程任务对象
2.把线程任务对象交给Thread处理
3.调用Thread的start();,启动线程,执行任务
4.线程执行完毕后,通过FutureTask的get方法去获取任务执行的结果
优点:
线程任务类只是实现接口,可以继续继承类和实现接口,扩展性强
缺点:
编码复杂一点
FutureTask的API
Thread类获取和修改线程名字
Thread类的API
也可以通过让自定义类调用Thread类的有参构造器,在创建对象时可以赋值
获取到当前的线程对象的方法
某些情况下,非Thread类子类对象没办法调用getName方法获取名称,我们可以通过此方法获取当前正在执行的线程对象再获取名字
Thread类的线程休眠方法
线程安全
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题
多个线程 同时操作 同一个共享资源
线程安全问题出现的原因:
存在多线程并发
同时访问共享资源
存在修改共享资源
线程同步
方式一:同步代码块
锁多条语句操作共享数据,可以使用同步代码块实现
作用:
把出现线程安全的问题的核心代码给上锁
原理:
每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
格式:
synchronized(任意对象){
多条语句操作共享
}
优点:
解决了多线程的数据安全问题
缺点:
当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
1.锁对象用任意唯一的对象好不好呢?
不好,会影响其他无关线程的执行
2.锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
方式二:同步方法
作用:
把出现线程安全问题的核心方法给上锁
原理:
每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
格式:
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理:
同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象
1.是同步代码块好还是同步方法好一点?
同步代码块锁的范围更小,同步方法锁的范围更大
方式三:Lock锁
java.util.concurrent.locks.ReentrantLock
为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象
ReentrantLock实现Lock接口
Lock的API
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private int a = 100;
public Lock lockObj = new ReentrantLock();
@Override
public void run() {
System.out.println("子类线程创建成功");
while (true) {
lockObj.lock();
a+=100;
try {
Thread.sleep(1);
String name = Thread.currentThread().getName();
System.out.println(name+"::"+a);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lockObj.unlock();
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
死锁
死锁是指:
两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
若无外力作用,它们都将无法推进下去
线程状态介绍
生产者与消费者
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者
线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public void xiaoFei() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
}
//被生产者线程调用,表示生产一个包子
public void shengChan() {
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Producer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == true) {
//有包子,生产者线程等待
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//没有包子
//生产一个包子
bz.shengChan();
//修改标记
bz.setFlag(true);
//唤醒消费者
bz.notify();//bz是锁对象
}
}
}
}
public class Consumer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Consumer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == false) {
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//有包子
//消费一个包子
bz.xiaoFei();
//修改标记
bz.setFlag(false);
bz.notify();//bz是锁对象
}
}
}
}
public class Demo03PC {
public static void main(String[] args) {
//创建线程共享资源包子类的对象
BaoZi03 bz = new BaoZi03();
//5.创建生产者线程任务对象
Producer03 pTask = new Producer03(bz);
//5.创建消费者线程任务对象
Consumer03 cTask = new Consumer03(bz);
//6.创建生产者线程对象,构造方法传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,构造方法传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象调用start方法,开启线程进行生产
pThread.start();
//9.消费者线程对象调用start方法,开启线程进行消费
cThread.start();
}
}
优化代码
public class BaoZi04 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public synchronized void xiaoFei() {
if (flag == false) {
//没有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
//修改标记
flag = false;
//唤醒生产者线程
notify();
}
//被生产者线程调用,表示生产一个包子
public synchronized void shengChan() {
if(flag == true) {
//有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
//没有包子,生产一个包子
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
//修改标记
flag = true;
//唤醒消费者线程
notify();
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Producer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.shengChan();//生产一个包子
}
}
public class Consumer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Consumer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.xiaoFei();//消费一个包子
}
}
//测试类
public class Demo04PC {
public static void main(String[] args) {
//创建多线程共享数据资源baoZi类的对象
BaoZi04 bz = new BaoZi04();
//4.创建生产者线程任务对象
Producer04 pTask = new Producer04(bz);
//6.创建消费者线程任务对象
Consumer04 cTask = new Consumer04(bz);
//6.创建生产者线程对象,传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象和消费者线程对象分别调用start方法开启线程
pThread.start();
cThread.start();
}
}
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
Thread类的API
也可以通过让自定义类调用Thread类的有参构造器,在创建对象时可以赋值
获取到当前的线程对象的方法
某些情况下,非Thread类子类对象没办法调用getName方法获取名称,我们可以通过此方法获取当前正在执行的线程对象再获取名字
Thread类的线程休眠方法
多个线程同时操作同一个共享资源的时候可能会出现业务安全问题
多个线程 同时操作 同一个共享资源
线程安全问题出现的原因:
存在多线程并发
同时访问共享资源
存在修改共享资源
线程同步
方式一:同步代码块
锁多条语句操作共享数据,可以使用同步代码块实现
作用:
把出现线程安全的问题的核心代码给上锁
原理:
每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
格式:
synchronized(任意对象){
多条语句操作共享
}
优点:
解决了多线程的数据安全问题
缺点:
当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
1.锁对象用任意唯一的对象好不好呢?
不好,会影响其他无关线程的执行
2.锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
方式二:同步方法
作用:
把出现线程安全问题的核心方法给上锁
原理:
每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
格式:
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理:
同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象
1.是同步代码块好还是同步方法好一点?
同步代码块锁的范围更小,同步方法锁的范围更大
方式三:Lock锁
java.util.concurrent.locks.ReentrantLock
为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象
ReentrantLock实现Lock接口
Lock的API
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private int a = 100;
public Lock lockObj = new ReentrantLock();
@Override
public void run() {
System.out.println("子类线程创建成功");
while (true) {
lockObj.lock();
a+=100;
try {
Thread.sleep(1);
String name = Thread.currentThread().getName();
System.out.println(name+"::"+a);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lockObj.unlock();
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
死锁
死锁是指:
两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
若无外力作用,它们都将无法推进下去
线程状态介绍
生产者与消费者
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者
线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public void xiaoFei() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
}
//被生产者线程调用,表示生产一个包子
public void shengChan() {
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Producer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == true) {
//有包子,生产者线程等待
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//没有包子
//生产一个包子
bz.shengChan();
//修改标记
bz.setFlag(true);
//唤醒消费者
bz.notify();//bz是锁对象
}
}
}
}
public class Consumer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Consumer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == false) {
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//有包子
//消费一个包子
bz.xiaoFei();
//修改标记
bz.setFlag(false);
bz.notify();//bz是锁对象
}
}
}
}
public class Demo03PC {
public static void main(String[] args) {
//创建线程共享资源包子类的对象
BaoZi03 bz = new BaoZi03();
//5.创建生产者线程任务对象
Producer03 pTask = new Producer03(bz);
//5.创建消费者线程任务对象
Consumer03 cTask = new Consumer03(bz);
//6.创建生产者线程对象,构造方法传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,构造方法传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象调用start方法,开启线程进行生产
pThread.start();
//9.消费者线程对象调用start方法,开启线程进行消费
cThread.start();
}
}
优化代码
public class BaoZi04 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public synchronized void xiaoFei() {
if (flag == false) {
//没有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
//修改标记
flag = false;
//唤醒生产者线程
notify();
}
//被生产者线程调用,表示生产一个包子
public synchronized void shengChan() {
if(flag == true) {
//有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
//没有包子,生产一个包子
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
//修改标记
flag = true;
//唤醒消费者线程
notify();
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Producer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.shengChan();//生产一个包子
}
}
public class Consumer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Consumer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.xiaoFei();//消费一个包子
}
}
//测试类
public class Demo04PC {
public static void main(String[] args) {
//创建多线程共享数据资源baoZi类的对象
BaoZi04 bz = new BaoZi04();
//4.创建生产者线程任务对象
Producer04 pTask = new Producer04(bz);
//6.创建消费者线程任务对象
Consumer04 cTask = new Consumer04(bz);
//6.创建生产者线程对象,传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象和消费者线程对象分别调用start方法开启线程
pThread.start();
cThread.start();
}
}
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
锁多条语句操作共享数据,可以使用同步代码块实现
作用:
把出现线程安全的问题的核心代码给上锁
原理:
每次只能一个线程进入,执行完毕后自动解锁,其他线程才可以进来执行
格式:
synchronized(任意对象){
多条语句操作共享
}
优点:
解决了多线程的数据安全问题
缺点:
当线程很多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率
1.锁对象用任意唯一的对象好不好呢?
不好,会影响其他无关线程的执行
2.锁对象的规范要求:
建议使用共享资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)对象作为锁对象
方式二:同步方法
作用:
把出现线程安全问题的核心方法给上锁
原理:
每次只能一个线程进入,执行完毕以后自动解锁,其他线程才可以进来执行
格式:
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
同步方法底层原理:
同步方法其实底层也是有隐式锁对象的,只是锁的范围是整个方法代码
如果方法是实例方法:同步方法默认用this作为的锁对象,但是代码要高度面向对象!
如果方法是静态方法:同步方法默认用类名.class作为的锁对象
1.是同步代码块好还是同步方法好一点?
同步代码块锁的范围更小,同步方法锁的范围更大
方式三:Lock锁
java.util.concurrent.locks.ReentrantLock
为了更清晰的表达如何加锁和解锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便,广泛的锁定操作
Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象
ReentrantLock实现Lock接口
Lock的API
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyRunnable implements Runnable {
private int a = 100;
public Lock lockObj = new ReentrantLock();
@Override
public void run() {
System.out.println("子类线程创建成功");
while (true) {
lockObj.lock();
a+=100;
try {
Thread.sleep(1);
String name = Thread.currentThread().getName();
System.out.println(name+"::"+a);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lockObj.unlock();
}
}
}
}
public class Test {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.setName("线程一");
thread2.setName("线程二");
thread1.start();
thread2.start();
}
}
死锁是指:
两个或两个以上的线程在执行过程中,由于竞争同步锁而产生的一种阻塞的现象
若无外力作用,它们都将无法推进下去
线程状态介绍
生产者与消费者
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者
线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public void xiaoFei() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子");
}
//被生产者线程调用,表示生产一个包子
public void shengChan() {
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Producer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == true) {
//有包子,生产者线程等待
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//没有包子
//生产一个包子
bz.shengChan();
//修改标记
bz.setFlag(true);
//唤醒消费者
bz.notify();//bz是锁对象
}
}
}
}
public class Consumer03 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi03 bz;
//构造方法
public Consumer03(BaoZi03 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true) {
//添加同步代码块
synchronized (bz) {
if(bz.getFlag() == false) {
try{bz.wait();}catch (Exception e){}//bz是锁对象
}
//有包子
//消费一个包子
bz.xiaoFei();
//修改标记
bz.setFlag(false);
bz.notify();//bz是锁对象
}
}
}
}
public class Demo03PC {
public static void main(String[] args) {
//创建线程共享资源包子类的对象
BaoZi03 bz = new BaoZi03();
//5.创建生产者线程任务对象
Producer03 pTask = new Producer03(bz);
//5.创建消费者线程任务对象
Consumer03 cTask = new Consumer03(bz);
//6.创建生产者线程对象,构造方法传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,构造方法传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象调用start方法,开启线程进行生产
pThread.start();
//9.消费者线程对象调用start方法,开启线程进行消费
cThread.start();
}
}
优化代码
public class BaoZi04 {
private int num;//给包子进行编号
//添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子
private boolean flag;
//被消费者线程调用,表示消费(打印输出)一个包子
public synchronized void xiaoFei() {
if (flag == false) {
//没有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子");
//修改标记
flag = false;
//唤醒生产者线程
notify();
}
//被生产者线程调用,表示生产一个包子
public synchronized void shengChan() {
if(flag == true) {
//有包子,等待
try {wait();}catch (Exception e){e.printStackTrace();}
}
//没有包子,生产一个包子
num++;
String threadName = Thread.currentThread().getName();
System.out.println(threadName+"生产第..."+num+"...个包子");
//修改标记
flag = true;
//唤醒消费者线程
notify();
}
public boolean getFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class Producer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Producer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.shengChan();//生产一个包子
}
}
public class Consumer04 implements Runnable{
//定义共享资源包子BaoZi类的对象
private BaoZi04 bz;
//构造方法
public Consumer04(BaoZi04 bz) {
this.bz = bz;
}
@Override
public void run() {
while (true)
bz.xiaoFei();//消费一个包子
}
}
//测试类
public class Demo04PC {
public static void main(String[] args) {
//创建多线程共享数据资源baoZi类的对象
BaoZi04 bz = new BaoZi04();
//4.创建生产者线程任务对象
Producer04 pTask = new Producer04(bz);
//6.创建消费者线程任务对象
Consumer04 cTask = new Consumer04(bz);
//6.创建生产者线程对象,传递生产者线程任务对象
Thread pThread = new Thread(pTask, "生产者线程");
//7.创建消费者线程对象,传递消费者线程任务对象
Thread cThread = new Thread(cTask, "消费者线程");
//8.生产者线程对象和消费者线程对象分别调用start方法开启线程
pThread.start();
cThread.start();
}
}
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
多个线程操作共享数据,线程任务是相同
多个线程操作共享数据,线程任务不相同
生产者实现步骤:
1.判断是否有包子 布尔标记
2.有: 等待
3.没有:
(1)生产一个包子:num++
(2)修改标记: true
(3)唤醒消费者
消费者实现步骤:
1.判断是否有包子 布尔标记
2.没有: 等待
3.有:
(1)消费一个包子
(2)修改标记: false
(3)唤醒生产者线程等待和唤醒的方法定义在java.lang.Object类中
public class BaoZi03 { private int num;//给包子进行编号 //添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子 private boolean flag; //被消费者线程调用,表示消费(打印输出)一个包子 public void xiaoFei() { String threadName = Thread.currentThread().getName(); System.out.println(threadName+"消费第~~~~~"+num+"~~~~~个包子"); } //被生产者线程调用,表示生产一个包子 public void shengChan() { num++; String threadName = Thread.currentThread().getName(); System.out.println(threadName+"生产第..."+num+"...个包子"); } public boolean getFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } }public class Producer03 implements Runnable{ //定义共享资源包子BaoZi类的对象 private BaoZi03 bz; //构造方法 public Producer03(BaoZi03 bz) { this.bz = bz; } @Override public void run() { while (true) { //添加同步代码块 synchronized (bz) { if(bz.getFlag() == true) { //有包子,生产者线程等待 try{bz.wait();}catch (Exception e){}//bz是锁对象 } //没有包子 //生产一个包子 bz.shengChan(); //修改标记 bz.setFlag(true); //唤醒消费者 bz.notify();//bz是锁对象 } } } }public class Consumer03 implements Runnable{ //定义共享资源包子BaoZi类的对象 private BaoZi03 bz; //构造方法 public Consumer03(BaoZi03 bz) { this.bz = bz; } @Override public void run() { while (true) { //添加同步代码块 synchronized (bz) { if(bz.getFlag() == false) { try{bz.wait();}catch (Exception e){}//bz是锁对象 } //有包子 //消费一个包子 bz.xiaoFei(); //修改标记 bz.setFlag(false); bz.notify();//bz是锁对象 } } } }public class Demo03PC { public static void main(String[] args) { //创建线程共享资源包子类的对象 BaoZi03 bz = new BaoZi03(); //5.创建生产者线程任务对象 Producer03 pTask = new Producer03(bz); //5.创建消费者线程任务对象 Consumer03 cTask = new Consumer03(bz); //6.创建生产者线程对象,构造方法传递生产者线程任务对象 Thread pThread = new Thread(pTask, "生产者线程"); //7.创建消费者线程对象,构造方法传递消费者线程任务对象 Thread cThread = new Thread(cTask, "消费者线程"); //8.生产者线程对象调用start方法,开启线程进行生产 pThread.start(); //9.消费者线程对象调用start方法,开启线程进行消费 cThread.start(); } }
优化代码public class BaoZi04 { private int num;//给包子进行编号 //添加布尔标记,true: 有包子,允许消费者消费包子,false: 没有包子,允许生产者生产包子 private boolean flag; //被消费者线程调用,表示消费(打印输出)一个包子 public synchronized void xiaoFei() { if (flag == false) { //没有包子,等待 try {wait();}catch (Exception e){e.printStackTrace();} } String threadName = Thread.currentThread().getName(); System.out.println(threadName+"消费第~~~~~~"+num+"~~~~~~个包子"); //修改标记 flag = false; //唤醒生产者线程 notify(); } //被生产者线程调用,表示生产一个包子 public synchronized void shengChan() { if(flag == true) { //有包子,等待 try {wait();}catch (Exception e){e.printStackTrace();} } //没有包子,生产一个包子 num++; String threadName = Thread.currentThread().getName(); System.out.println(threadName+"生产第..."+num+"...个包子"); //修改标记 flag = true; //唤醒消费者线程 notify(); } public boolean getFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } } public class Producer04 implements Runnable{ //定义共享资源包子BaoZi类的对象 private BaoZi04 bz; //构造方法 public Producer04(BaoZi04 bz) { this.bz = bz; } @Override public void run() { while (true) bz.shengChan();//生产一个包子 } } public class Consumer04 implements Runnable{ //定义共享资源包子BaoZi类的对象 private BaoZi04 bz; //构造方法 public Consumer04(BaoZi04 bz) { this.bz = bz; } @Override public void run() { while (true) bz.xiaoFei();//消费一个包子 } } //测试类 public class Demo04PC { public static void main(String[] args) { //创建多线程共享数据资源baoZi类的对象 BaoZi04 bz = new BaoZi04(); //4.创建生产者线程任务对象 Producer04 pTask = new Producer04(bz); //6.创建消费者线程任务对象 Consumer04 cTask = new Consumer04(bz); //6.创建生产者线程对象,传递生产者线程任务对象 Thread pThread = new Thread(pTask, "生产者线程"); //7.创建消费者线程对象,传递消费者线程任务对象 Thread cThread = new Thread(cTask, "消费者线程"); //8.生产者线程对象和消费者线程对象分别调用start方法开启线程 pThread.start(); cThread.start(); } }
线程池
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
ExecutorService
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:
使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法
新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
Executors
Executors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险
线程池就是一个可以复用线程的技术
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能
JDK5.0起提供了代表线程池的接口
获得线程池:
方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
方式二:
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
ThreadPoolExecutor
ThreadPoolExecutor构造器的参数说明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
ThreadPoolExecutor创建线程池对象示例
ExecutorService pools = new ThreadPoolExecutor(3, 5
, 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
ExecutorService的常用方法 新任务拒绝策略
参数一:指定线程池的线程数量(核心线程): corePoolSize 不能小于0
参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量
参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0
参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位
参数五:指定任务队列: workQueue 不能为null
参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null
参数七:指定线程忙,任务满的时候,新任务来了怎么办: handler 不能为null
1.临时线程什么时候创建啊?
新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程
2.什么时候会开始拒绝任务?
核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝
ExecutorsExecutors得到线程池对象的常用方法
线程池的工具类通过调用方法返回不同类型的线程池对象
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险(阿里开发手册)
1.Executors工具类底层是基于什么方式实现的线程池对象?
线程池ExecutorService的实现类:ThreadPoolExecutor
2.Executors是否适合做大型互联网场景的线程池方案?
不合适
建议使用ThreadPoolExecutor来指定线程池参数,这样可以明确线程池的运行规则,规避资源耗尽的风险



