一:程序、进程、线程
1.1 什么是程序
程序(program):是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码。 (程序是静态的)
1.2 什么是进程
进程(process):是程序的一次执行过程,正在运行的一个程序,进程作为资源分配的单位,在内存中会为每个进程分配不同的内存区域。 (进程是动态的)是一个动的过程 ,进程的生命周期 : 有它自身的产生、存在和消亡的过程
1.3 什么是线程
线程(thread):进程中的一条执行路径,也是CUP的基本调度单位,一个进程由一个或多个线程组成,彼此间完成不同的工作,多个线程同时执行,称为多线程。
1.3.1 线程的组成
任何一个线程都具有的基本组成部分:
- CPU时间片:操作系统(OS)会为每一个线程分配执行时间。
- 运行数据:堆空间(存储线程需要使用的对象,多个线程可以共享堆中的对象);栈空间(存储线程需要使用的局部变量,每个线程都拥有独立的栈)
1.3.2 线程的特点
- 线程抢占式执行(效率高、可防止单一线程长时间独占CPU)
- 单核CPU在执行的时候,是按照时间片执行的,一个时间片只能执行一个线程,因为时间片特别的短,我们感受到的就是“同时”进行的。
- 多核CPU真正意义上做到了一个时间片多个线程同时进行
- 在单核CPU中,宏观上同时进行,微观上顺序执行
1.4 进程和线程的区别
- 进程是操作系统中资源分配的基本单位,而线程是CPU的基本调度单位
- 一个程序运行后至少有一个进程
- 一个进程可以包含多个线程,但是至少需要有一个线程,否则这个进程是没有意义的
- 进程间不能共享数据段地址,但通进程的线程之间可以。
二:创建线程的四种方式
2.1 继承Thread类重写run()方法
具体实现
1.继承Thread类
2.重写run()方法
3.创建子类对象
4.调用start()方法(PS:不要调用run()方法,这样相当于普通调用对象的方法,并为启动线程)
继承类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
System.out.println("子线程:==>" + i);
}
}
}
测试类
public class TestThread {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
for (int i = 1; i <= 50; i++) {
System.out.println("主线程:-->"+i);
}
}
}
结果
获取线程ID和名称
- getId()//获取线程的id,每个线程都有自己的id
- getName()//获取线程名字
- Thread.currentThread()//获取当前线程
代码
public class TestThread {
public static void main(String[] args) {
MyThread t=new MyThread();
t.start();
//只能在继承Thread类的情况下用
System.out.println("线程id:"+t.getId());
System.out.println("线程名字:"+t.getName());
//调用Thread类的静态方法获取当前线程(这里获取的是主线程)
System.out.println("线程id:"+Thread.currentThread().getId());
System.out.println("线程名字:"+Thread.currentThread().getName());
}
}
修改线程名称
只能修改线程的名称,不能修改线程的id(id是由系统自动分配)
1、使用线程子类的构造方法赋值
2、调用线程对象的setName()方法
代码
public class MyThread extends Thread{
public MyThread() {}//无参构造器
public MyThread(String name) {
super(name);
}
public void run() {
for(int i=1;i<=50;i++) {}
}
}
public class TestThread {
public static void main(String[] args) {
MyThread t1=new MyThread("子线程1");//通过构造方法
MyThread t2=new MyThread();
t2.setName("子线程2");
System.out.println("线程t1的id:"+t1.getId()+" 名称:"+t1.getName());
System.out.println("线程t2的id:"+t2.getId()+" 名称:"+t2.getName());
}
}
2.2 实现Runnable接口实现run()方法
具体实现
1.实现Runnable接口
2.实现run()方法
3.创建实现类对象
4.创建线程类对象
5.调用start()方法
实现接口
public class MyRunnable implements Runnable{//实现接口
@Override
public void run() {//实现run方法
// TODO Auto-generated method stub
for(int i=1;i<=10;i++) {
System.out.println("子线程:"+i);
}
}
}
测试类
public class TestRunnable {
public static void main(String[] args) {
//1.创建MyRunnable对象,表示线程执行的功能
Runnable runnable=new MyRunnable();
//2.创建线程对象
Thread th=new Thread(runnable);
//3.启动线程
th.start();
for(int i=1;i<=10;i++) {
System.out.println("主线程:"+i);
}
}
}
使用匿名内部类
如果一个线程方法我们只使用一次,那么就不必设置一个单独的类,就可以使用匿名内部类实现该功能
public class TestRunnable {
public static void main(String[] args) {
Runnable runnable=new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=1;i<=10;i++) {
System.out.println("子线程:"+ i);
}
}
};
Thread th=new Thread(runnable);
th.start();
}
}
2.3 实现Callable接口
Callable和Thread、Runnable比较
对比继承Thread类和实现Runnable接口创建线程的方式发现,都需要有一个run()方法,但是这个run()方法有不足:
- 没有返回值
- 不能抛出异常
基于上面的两个不足,在JDK1.5以后出现了第三种创建线程的方式:实现Callable接口
实现Callable接口的好处:
- 有返回值
- 能抛出异常
缺点:
- 创建线程比较麻烦
1.实现Callable接口,可以不带泛型,如果不带泛型,那么call方法的返回值就是Object类型
2.如果带泛型,那么call的返回值就是泛型对应的类型
3.从call方法看到:方法有返回值,可以抛出异常
实现接口
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
return new Random().nextInt(10);
}
}
测试类
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
TestCallable tc=new TestCallable();
FutureTask<Integer> ft=new FutureTask<>(tc);
//创建线程对象
Thread th=new Thread(ft);
th.start();
//获取线程得到的返回值
Integer In=ft.get();
System.out.println(In);
}
}
2.4 线程池
2.4.1 开发中为什么使用线程池
- 降低资源的消耗 ——通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
- 提高响应速度——因为线程池中的线程数没有超过线程池的最大上限时,有的线程处于等待分配任务 的状态,当任务来时无需创建新的线程就能执行
- 提高线程的可管理性 ——线程池会根据当前系统特点对池内的线程进行优化处理,减少创建和销毁线程带来 的系统开销。无限的创建和销毁线程不仅消耗系统资源,还降低系统的稳定性,使 用线程池进行统一分配
2.4.2 创建线程池
- newCachedThreadPool —— 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若 无可回收,则新建线程。
- newFixedThreadPool——创建一个固定大小线程池,可控制线程最大并发数,超出的线程会在队列中等待。核心线程等于最大线程,都不可以回收。
- newScheduledThreadPool——创建一个定时任务线程池,支持定时及周期性任务执行。
- newSingleThreadExecutor——创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务 按照指定顺序(FIFO, LIFO, 优先级)执行。
2.4.3 线程池的七大参数
- corePoolSize:【5】核心线程数;线程池中一直保持的线程的数量,即使线程空闲。除非设置了(allowCoreThreadTimeOut )
- maximumPoolSize: 池中允许的最大的线程数 ,控制资源
- keepAliveTime: 存活时间,当线程数大于核心线程数的时候,线程在最大多长时间没有接到新任务就会终止释放, 最终线程池维在 corePoolSize 大小
- unit: 时间单位
- workQueue 阻塞队列,用来存储等待执行的任务,如果当前对线程的需求超过了 corePoolSize 大小,就会放在这里等待空闲线程执行。
- threadFactory 创建线程的工厂,比如指定线程名等
- handler 拒绝策略,如果线程满了,线程池就会使用拒绝策略,拒绝执行任务。
2.4.4 运行流程
1、线程池创建,准备好 core 数量的核心线程,准备接受任务
2、新的任务进来,用 core 准备好的空闲线程执行。
(1) 、core 满了,就将再进来的任务放入阻塞队列中。空闲的 core 就会自己去阻塞队 列获取任务执行
(2) 、阻塞队列满了,就直接开新线程执行,最大只能开到 max 指定的数量
(3) 、max 都执行好了。Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自动销毁。最终保持到 core 大小
(4) 、如果线程数开到了 max 的数量,还有新任务进来,就会使用 reject 指定的拒绝策 略进行处理
3、所有的线程创建都是由指定的 factory 创建的。
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,
200,
10,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(100000),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);
2.4.5 举例
一个线程池 core 7; max 20 ,queue:50,100 并发进来怎么分配的
答:先有 7 个能直接得到执行,接下来 50 个进入队列排队,在多开 13 个继续执行。现在 70 个 被安排上了。剩下 30 个默认拒绝策略。
2.5 总结
- 方式 1 和方式 2:主进程无法获取线程的运算结果。无返回值。
- 方式 3:主进程可以获取线程的运算结果,但是不利于控制服务器中的线程资源。可以导致 服务器资源耗尽。
- 方式 1 ,方式 2和方式 3,都不可以控制资源
- 方式4:通过线程池性能稳定,也可以获取执行结果,并捕获异常。但是,在业务复杂情况下,一 个异步调用可能会依赖于另一个异步调用的执行结果。
- 一般情况下我们都使用线程池去管理线程。
三:线程的状态
3.1 基本四状态
3.2 等待状态
3.3 阻塞状态
四:线程常用的方法
-
休眠(当前线程主动休眠millis毫秒)
public static void sleep(long millis)
-
放弃(当前线程主动放弃时间片,回到就绪状态,竞争下一次时间片)
public static void yield()
-
加入(当一个线程调用了join方法,这个线程就会先被执行,它执行结束以后才可以去执行其余的线程)
public final void join()
//必须先start(),在join(),才有效 -
优先级(线程优先级为1–10,默认为5,优先级越高,表示获取CPU机会越多)
线程对象.setPriority()
-
守护线程
- 线程对象.setDaemon(true);设置为守护线程
- 线程有两类:用户线程(前台线程)、守护线程(后台线程)
- 如果程序中所有前台线程都执行完毕了,后台线程也会自动结束
- 垃圾回收器线程属于守护线程
4.1 线程休眠(sleep):线程主动休眠millis毫秒
子线程
public class SleepThread extends Thread{
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
PS:sleep()的异常在run方法中是不能抛出的,只能用try–catch处理
测试类
public class Test01 {
public static void main(String[] args) {
SleepThread sleepThread = new SleepThread();
sleepThread.start();
}
}
4.2 线程放弃(yield):当前线程主动放弃时间片,回到就绪状态,竞争下一次时间片
使当前线程从执行状态(运行状态)变为可执行态(就绪状态)。cpu会从众多的可执行态里选择,也就是说,当前也就是刚刚的那个线程还是有可能会被再次执行到的,并不是说一定会执行其他线程而该线程在下一次中不会执行到了。
Java线程中有一个Thread.yield()方法,很多人翻译成线程让步。顾名思义,就是说当一个线程使用了这个方法之后,它就会把自己CPU执行的时间让掉,让自己或者其它的线程运行。
打个比方:现在有很多人在排队上厕所,好不容易轮到这个人上厕所了,突然这个人说:“我要和大家来个竞赛,看谁先抢到厕所!”,然后所有的人在同一起跑线冲向厕所,有可能是别人抢到了,也有可能他自己有抢到了。我们还知道线程有个优先级的问题,那么手里有优先权的这些人就一定能抢到厕所的位置吗?
答:不一定的,他们只是概率上大些,也有可能没特权的抢到了。
package com.yield;
public class YieldTest extends Thread {
public YieldTest(String name) {
super(name);
}
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
System.out.println("" + this.getName() + "-----" + i);
// 当i为30时,该线程就会把CPU时间让掉,让其他或者自己的线程执行(也就是谁先抢到谁执行)
if (i == 30) {
this.yield();
}
}
}
public static void main(String[] args) {
YieldTest yt1 = new YieldTest("张三");
YieldTest yt2 = new YieldTest("李四");
yt1.start();
yt2.start();
}
}
4.3 线程加入(join):这个线程就会先被执行,它执行结束以后才可以去执行其余的线程,必须先start,再join才有效
在线程2中调用线程1的join方法,当线程调用了这个方法时,线程1会强占CPU资源,直到线程执行结果为止(谁调用join方法,谁就强占cpu资源,直至执行结束)
这里说的是强占,而不是抢占,也就是说当这个线程调用 了join方法后,线程抢占到CPU资源,它就不会再释放,直到线程执行完毕。
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(()->{
try {
Thread.sleep(500);
System.out.println("线程1醒了");
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<100;i++){
System.out.println("线程1 i:"+i);
}
});
t1.setName("线程1");
Thread t2 = new Thread(()->{
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<100;i++){
System.out.println("线程2 i:"+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t2.setName("线程2");
t2.start();
t1.start();
}
输出结果:
线程1醒了
线程1 i:0
线程1 i:1
线程1 i:2
线程1 i:3
线程1 i:4
线程1 i:5
……
线程1 i:99
线程2 i:0
线程2 i:1
线程2 i:2
线程2 i:3
线程2 i:4
……
线程2 i:99
4.4 守护线程(setDaemon)
将子线程设置为主线程的伴随线程,主线程停止的时候,子线程也不要继续执行了
注意:先设置,在启动
子线程
public class TestThread extends Thread{
@Override
public void run() {
for(int i=1;i<=1000;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
测试类
public class Test01 {
public static void main(String[] args) throws InterruptedException {
TestThread daemonThread = new TestThread();
daemonThread.setDaemon(true);//设置守护线程
daemonThread.start();
for (int i=1;i<=10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
Thread.sleep(100);
}
}
}
结果:当主线程结束时,子线程也跟着结束,并不会继续执行下去打印输出
4.4 线程优先级(setPriority)
线程优先级为1-10,默认为5,优先级越高,表示获取CPU机会越多
代码
public class TestThread extends Thread{
@Override
public void run() {
for(int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class Test01 {
public static void main(String[] args) throws InterruptedException {
TestThread th1 = new TestThread();
TestThread th2 = new TestThread();
TestThread th3 = new TestThread();
th1.setPriority(10);//设置线程1优先级10
th1.start();
th2.start();//线程2优先级默认不变,为5
th3.setPriority(1);//设置线程3优先级为1
th3.start();
}
}
结果:优先级(th1>th2>th3)线程3应该在最后打印
五、线程安全问题
5.1 卖票案例
需求:模拟三个窗口,每个窗口有100个人,同时抢10张票
代码案例:
public class BuyTicketRunnable implements Runnable{
private int ticketNum=10;
@Override
public void run() {
for(int i=1;i<=100;i++) {
if(ticketNum<=0) break;
System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票!");
ticketNum--;
}
}
}
public class BuyTicketTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Runnable runnable=new BuyTicketRunnable();
Thread th1=new Thread(runnable,"窗口1");
Thread th2=new Thread(runnable,"窗口2");
Thread th3=new Thread(runnable,"窗口3");
th1.start();
th2.start();
th3.start();
}
}
运行结果
结果分析:
我们发现,不同窗口会抢到同一张票!!!,这在实际情况是不允许的,这是因为多个线程,在争抢资源的过程中,导致共享的资源出现问题。一个线程还没执行完,另一个线程就参与进来了,开始争抢。(但窗口2抢到第10张票,还没来得及ticketNum–操作,时间片就用完了,随后被窗口三抢到CPU资源,此时的票数还是10,窗口三也抢到第十张票,也还没来得及ticketNum–操作窗口三时间片由完了,窗口一抢到CPU资源,还是买到了第10张票)
5.2 多线程安全问题
- 当多线程并发访问临界资源时,如果破坏原子操作,可能会造成数据不一致
- 临界资源:共享资源(同一对象),一次只能允许一个线程使用,才可以保证其正确性
- 原子操作:不可分割的多步操作,被视作一个整体,其顺序和步骤不可被打乱或缺省
5.3 同步代码块
synchronized(同步监视器){
//…
}
- 必须是引用数据类型,不能是基本数据类型
- 也可以创建一个专门的同步监视器,没有任何业务含义 (new Object)
- 一般使用共享资源做同步监视器即可
- 在同步代码块中不能改变同步监视器对象的引用
- 尽量不要String和包装类Integer做同步监视器,建议使用final修饰同步监视器
对卖票案例改进
public class BuyTicketRunnable implements Runnable{
static Object obj=new Object();
private int ticketNum=10;
@Override
public void run() {
for(int i=1;i<100;i++) {
//把具有安全隐患的代码锁住即可,如果锁多了就会效率低
synchronized (obj) {//锁必须多个线程用的是同一把锁!!也可以使用this,表示的是该对象本身
System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票!");
ticketNum--;
}
}
}
}
结论:
- 多个代码块使用了同一个同步监视器(锁),锁住一个代码块的同时,也锁住所有使用该锁的所有代码块,其他线程无法访问其中的任何一个代码块
- 多个代码块使用了同一个同步监视器(锁),锁住一个代码块的同时,也锁住所有使用该锁的所有代码块, 但是没有锁住使用其他同步监视器的代码块,其他线程有机会访问其他同步监视器的代码块
5.4 同步方法
synchronized(同步方法)
- 不要将run()定义为同步方法
- 非静态同步方法的同步监视器是this;静态同步方法(static)的同步监视器是 类名.class 字节码信息对象
- 同步代码块的效率要高于同步方法(原因:同步方法是将线程挡在了方法的外部,而同步代码块锁将线程挡在了代码块的外部,但是却是方法的内部)
- 同步方法的锁是this,一旦锁住一个方法,就锁住了所有的同步方法;同步代码块只是锁住使用该同步监视器的代码块,而没有锁住使用其他监视器的代码块
买票案例改进:
public class BuyTicketRunnable implements Runnable{
private int ticketNum=10;
@Override
public void run() {
for(int i=1;i<100;i++) {
BuyTicket();
}
}
public synchronized void BuyTicket() {//锁住的是:this,如果是静态方法:当前类.class
if(ticketNum>0) {
System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票!");
ticketNum--;
}
}
}
5.5 Lock锁
5.5.1 Lock锁介绍
- DK1.5后新增新一代的线程同步方式:Lock锁,与采用synchronized相比,lock可提供多种锁方案,更灵活
- synchronized是Java中的关键字,这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。但是Lock锁是API级别的,提供了相应的接口和对应的实现类,这个方式更灵活,表现出来的性能优于之前的方式。
5.5.2 使用Lock锁对买票案例改进
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BuyTicketRunnable implements Runnable{
private int ticketNum=10;
Lock lock=new ReentrantLock();//接口=实现类 可以使用不同的实现类
@Override
public void run() {
for(int i=1;i<100;i++) {
lock.lock();//打开锁
try {
if(ticketNum>0) {
System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票!");
ticketNum--;
}
}catch(Exception e) {
e.printStackTrace();
}finally {
//关闭锁:--->即使有异常,这个锁也可以得到释放
lock.unlock();
}
}
}
}
5.5.3 Lock和synchronized的区别
- Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
5.6 线程死锁
5.6.1 死锁介绍
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
5.6.2 案例
男孩女孩一起去吃饭,但是桌子上只有两根筷子,如果两个人同时抢到一根筷子而不放弃,这样两个人都吃不上饭,这样就形成死锁了;必须要有一个人放弃争抢,等待另一个人用完,释放资源,这个人之后才会获得两根筷子,两个人才能都吃上饭
5.6.3 代码实现
package 多线程;
class Eat{
//代表两个筷子
public static Object o1=new Object();
public static Object o2=new Object();
public static void eat() {
System.out.println("可以吃饭了");
}
}
class BoyThread extends Thread{
public void run() {
synchronized (Eat.o1) {
System.out.println("男孩拿到了第一根筷子!");
synchronized (Eat.o2) {
System.out.println("男孩拿到了第二根筷子!");
Eat.eat();
}
}
}
}
class GirlThread extends Thread{
public void run() {
synchronized (Eat.o2) {
System.out.println("女孩拿到了第二根筷子!");
synchronized (Eat.o1) {
System.out.println("女孩拿到了第一根筷子!");
Eat.eat();
}
}
}
}
public class MyLock {
public static void main(String[] args) {
BoyThread boy=new BoyThread();
GirlThread girl=new GirlThread();
boy.start();
girl.start();
}
}
结果:
5.6.4 解决办法
先让男孩拿到筷子,线程休眠一下,等待男孩用完筷子,在启动女孩线程
public class MyLock {
public static void main(String[] args) {
BoyThread boy=new BoyThread();
GirlThread girl=new GirlThread();
boy.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
girl.start();
}
}
六:线程通信问题
在Java对象中,有两种池
- 锁池(synchronized)
- 等待池(wait();notify();notifyAll())
- 如果一个线程调用了某个对象的wait方法,那么该线程进入到该对象的等待池中(并且已经将锁释放);
- 如果未来的某个时刻,另外一个线程调用了相同的对象notify方法或者notifyAll方法,那么该等待池中的线程就会被唤醒,然后进入到对象的锁池里面去获得该对象的锁;
- 如果获得锁成功后,那么该线程就会沿着wait方法之后的路径继续执行。注意:沿着wait方法之后执行
6.1 wait()和wait(long timeout)
- wait():的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。直到其他线程调用此对象的notify() 方法或 notifyAll() 方法,当前线程被唤醒(进入就绪状态)
- wait(long timeout):让当前线程处于“等待(阻塞)状态,直到其他线程调用此对象的notify()方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入就绪状态)
sleep和wait的区别:sleep进入阻塞状态没有释放锁,wait进入阻塞状态但是同时释放了锁
6.2 notify()和notifyAll():唤醒当前对象上的等待线程
- notify()是唤醒单个线程
- notifyAll()是唤醒所有的线程
6.3 生产者和消费者问题
案例:
假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止
6.3.1 功能分解一:商品类
public class Product {//商品类
private String name;//名字
private String brand;//品牌
boolean flag = false;//设置标记,false表示商品没有,等待生产者生产
public synchronized void setProduct(String name, String brand) {//生产商品,同步方法,锁住的是this
if (flag == true) {//如果flag为true,代表有商品,不生产,等待消费者消费
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生产商品
this.setName(name);
this.setBrand(brand);
System.out.println("生产者生产了" +this.getBrand() +this.getName());
//生产完,设置标志
flag = true;
//唤醒消费线程
notify();
}
public synchronized void getProduct() {
if (flag == false) {//如果是false,则没有商品,等待生产者生产
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果有商品,消费
System.out.println("消费者消费了" + this.getBrand() +this.getName());
//设置标志
flag = false;
//唤醒线程
notify();
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getBrand() {
return brand;
}
}
6.3.2 功能分解二:生产者线程
public class ProducterThread extends Thread {//生产者线程
private Product p;
public ProducterThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
if(i%2==0){//如果是奇数,就生产巧克力,如果是偶数,就生产方便面
p.setProduct("巧克力","德芙");
}else{
p.setProduct("方便面","康师傅");
}
}
}
}
6.3.3 功能分解三:消费者线程
public class CustomerThread extends Thread {//消费者线程
private Product pro;
public CustomerThread(Product pro) {
this.pro = pro;
}
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
pro.getProduct();
}
}
}
6.3.4 测试类
public class Test {
public static void main(String[] args) {
Product p = new Product();
ProducterThread pth = new ProducterThread(p);
CustomerThread cth = new CustomerThread(p);
pth.start();
cth.start();
}
}
6.3.5 结果
生产者生产一件商品,消费者消费一件商品,交替进行