13 多线程
13 多线程
13.1 程序、进程、线程
【1】程序、进程、线程
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合，是一段静态的代码。（程序是静态的）
进程（process）：是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。（进程是动态的）
是一个动的过程，进程的生命周期：有它自身的产生、存在和消亡的过程。
线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。
【2】单核CPU和多核CPU
以上图片来自网络
【3】并行和并发
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）
13.2 创建线程的三种方式
13.2.1 继承Thread类
【1】在学习多线程一章之前，以前的代码是单线程的吗？不是，以前也是有三个线程同时执行的。
1.main方法对应的主线程，2.处理异常的线程，3.垃圾收集器线程。
异常线程会影响主线程的执行。
package com.liweixiao.test01;
/**
* @author:LiWeixiao
* @date:2023/2/9
* @description:线程类
* 继承Thread类，才具备争抢资源的能力
*/
public class TestThread extends Thread{
/*
必须重写Thread类中的run方法，然后线程的任务/逻辑写在run方法中
*/
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("thread---"+i);
}
}
}
package com.liweixiao.test01;
/**
* @author:LiWeixiao
* @date:2023/2/9
* @description:
*/
public class Test {
public static void main(String[] args) {
//主线程中输出10个数
for (int i = 1; i <= 10; i++) {
System.out.println("main1---"+i);
}
//制作其他线程，跟主线程争抢资源
//子线程，和下面的主线程争抢资源
TestThread tt = new TestThread();
//tt.run();//调用run方法，执行线程中的任务 -》 这个run方法不能直接调用，直接调用被当做一个普通方法
//想要tt子线程起作用，要启动线程：
tt.start();//start()是Thread类中的方法
//主线程中输出10个数
for (int i = 1; i <= 10; i++) {
System.out.println("main2---"+i);
}
}
}
设置读取线程名字
【1】setName、getName
package com.liweixiao.test01;
/**
* @author:LiWeixiao
* @date:2023/2/9
* @description:
*/
public class Test {
public static void main(String[] args) {
//给main方法主线程设置名字
Thread.currentThread().setName("主线程");
//主线程中输出10个数
for (int i = 1; i <= 10; i++) {
System.out.println("main---"+i);
}
//制作其他线程，跟主线程争抢资源
//子线程，和下面的主线程争抢资源
TestThread tt = new TestThread();
tt.setName("子线程");
//tt.run();//调用run方法，执行线程中的任务 -》 这个run方法不能直接调用，直接调用被当做一个普通方法
//想要tt子线程起作用，要启动线程：
tt.start();//start()是Thread类中的方法
//主线程中输出10个数
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
【2】通过构造器设置
public class TestThread extends Thread{
public TestThread(String name){
super(name);//调用父类的有参构造器
}
}
买火车票
package com.liweixiao.test02;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:买火车票线程
*/
public class BuyTicketThread extends Thread{
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum=10;
//每个窗口都是一个线程对象，每个对象执行的代码放入run方法中
@Override
public void run() {
//每个窗口后面有100个人在排队
for (int i = 1; i <= 100; i++) {
if(ticketNum > 0){//大于0才有票
System.out.println("我在"+this.getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
}
package com.liweixiao.test02;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class Test {
public static void main(String[] args) {
//多个窗口抢票，三个窗口三个线程对象
BuyTicketThread t1 = new BuyTicketThread("窗口1");
t1.start();
BuyTicketThread t2 = new BuyTicketThread("窗口2");
t2.start();
BuyTicketThread t3 = new BuyTicketThread("窗口3");
t3.start();
//
}
}
13.2.2 实现Runnable接口
【1】代码
package com.liweixiao.test03;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:实现Runnable接口，变成一个线程类
*/
public class TestThread implements Runnable{
//重写run方法
@Override
public void run() {
//输出1~10数字
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+"---"+i);
}
}
}
package com.liweixiao.test03;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class Test {
public static void main(String[] args) {
//创建子线程对象
TestThread tt = new TestThread();
Thread t = new Thread(tt,"子线程");
t.start();
//主线程里面也是打印1~10
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
买火车票
package com.liweixiao.test04;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class BuyTicketThread implements Runnable{
//一共10张火车票
int ticketNum=10;
//实现run方法
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if(ticketNum>0){
System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
}
package com.liweixiao.test04;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class Test {
public static void main(String[] args) {
//定义一个线程对象
BuyTicketThread t = new BuyTicketThread();
//窗口1买票
Thread t1 = new Thread(t,"窗口1");
t1.start();
//窗口2买票
Thread t2 = new Thread(t, "窗口2");
t2.start();
//窗口3买票
Thread t3 = new Thread(t, "窗口3");
t3.start();
}
}
说明：可能有问题，出现买了重复的车票，存在安全隐患。
【2】实际开发中，方式1继承Thread类 还是 方式2实现Runnable接口？
（1）方式1的话有 Java单继承的局限性，因为继承了Thread类，就不能再继承其它的类了
（2）方式2的共享资源的能力也会强一些，不需要非得加个static来修饰
Thread类 实现了 Runnable接口
13.2.3 实现Callable接口
第一种和第二种创建线程的方式，都要依赖run方法。这个run方法不足，1.没有返回值，2.不能抛出异常。
JDK1.5以后出现第三种创建线程方式，实现Callable接口。
package com.liweixiao.test05;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class TestRandomNum implements Callable<Integer> {
/*1.实现Callable接口，可以不带泛型，返回object
2.如果带泛型，返回值是对应的类型
3.方法有返回值，可以抛出异常
*/
@Override
public Integer call() throws Exception {
//返回10以内的随机数
return new Random().nextInt(10);
}
}
class Test{
public static void main(String[] args) throws ExecutionException, InterruptedException {
//定义一个线程对象
TestRandomNum trn = new TestRandomNum();
FutureTask ft = new FutureTask(trn);
Thread t = new Thread(ft);
t.start();
//获取线程得到的返回值
Object obj = ft.get();
System.out.println(obj);
}
}
13.3 线程的生命周期
【1】线程生命周期：线程开始 -》 线程消亡
【2】线程经历哪些阶段
以上图片来自网络
13.4 线程的常见方法
1.start()，启动当前线程，表面上调用start方法，实际调用线程里面的run方法
2.run()，线程类 继承 Thread类 或者 实现 Runnable接口的时候，都要重新实现run方法，run方法里面是线程要执行的内容
3.currentThread：Thread类中的一个静态方法，获取当前正在执行的现场
4.setName 设置线程名字
5.getName 读取线程名字
13.4.1 设置优先级
【1】同优先级的线程，采取策略是先到先得服务，使用时间片策略
【2】如果优先级高，被cpu调度的概率高
【3】级别
MIN_PRIORITY=1
NORM_PRIORITY=5
MAX_PRIORITY=10
package com.liweixiao.test06;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class TestThread01 extends Thread{
@Override
public void run() {
for (int i = 1; i <=100 ; i++) {
System.out.println(i);
}
}
}
class TestThread02 extends Thread{
@Override
public void run() {
for (int i = 201; i <=300 ; i++) {
System.out.println(i);
}
}
}
class Test{
public static void main(String[] args) {
//创建2个子线程，争抢资源
TestThread01 t1 = new TestThread01();
t1.setPriority(1);
t1.start();
TestThread02 t2 = new TestThread02();
t2.setPriority(10);
t2.start();
}
}
13.4.2 join
join方法：当一个线程调用了join方法，这个线程会先被执行，它执行结束以后才可以执行其余的线程。
package com.liweixiao.test07;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class TestThread extends Thread{
public TestThread(String name){
super(name);
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {
System.out.println(this.getName()+"---"+i);
}
}
}
class Test{
public static void main(String[] args) throws InterruptedException {
for (int i = 1; i <=100 ; i++) {
System.out.println("main---"+i);
if(i==6){
//创建子线程
TestThread tt = new TestThread("子线程");
tt.start();//先启动
tt.join();//半路杀出个程咬金
}
}
}
}
13.4.3 sleep
【1】sleep，人为的制造阻塞方法
package com.liweixiao.test08;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class Test01 {
public static void main(String[] args) {
System.out.println("00000000000000");
System.out.println(System.currentTimeMillis());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis());
System.out.println("11111111111111");
}
}
【2】案例：完成秒表功能
package com.liweixiao.test08;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class Test02 {
public static void main(String[] args) throws InterruptedException {
//2.定义时间格式
DateFormat df = new SimpleDateFormat("HH:mm:ss");
//3.按照定义的格式将Date转为指定格式的字符串
while (true){
//1.获取当然时间
Date d = new Date();
System.out.println(df.format(d));
Thread.sleep(1000);
}
}
}
13.4.4 setDaemon
【1】设置伴随线程
子线程设置为主线程的伴随线程，主线程停止的时候，子线程不要继续执行了。
皇上 -》 驾崩 -》 妃子陪葬
package com.liweixiao.test09;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class TestThread extends Thread{
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
System.out.println("子线程---"+i);
}
}
}
class Test{
public static void main(String[] args) {
//创建并启动子线程
TestThread tt = new TestThread();
tt.setDaemon(true);//先设置，再启动
tt.start();
//创建主线程
for (int i = 1; i <= 10; i++) {
System.out.println("main---"+i);
}
}
}
13.4.5 stop
package com.liweixiao.test09;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <=100 ; i++) {
System.out.println(i);
if(i==10){
Thread.currentThread().stop();//过期方法，不建议使用
}
}
}
}
13.5 线程安全问题
【1】出现问题：
（1）出现了两个10张票或者3个10张票：
以上图片来自网络
（2）出现0，-1，-2可能：
以上图片来自网络
上面的代码出现问题：出现了 重票，错票，---》 线程安全引起的问题
原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。
解决：
在我的程序中，加入“锁” --》加同步 --》同步监视器
13.5.1 方法1：同步代码块
【1】演示，implements Runnable
package com.liweixiao.test04;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class BuyTicketThread implements Runnable{
//一共10张火车票
int ticketNum=10;
//实现run方法
@Override
public void run() {
//此处有1000行代码
for (int i = 1; i <= 100; i++) {
synchronized (this){//把具有安全隐患的代码锁住，如果锁多了就会效率低 -》 this就是这个锁
if(ticketNum>0){
System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
//此处有1000行代码
}
}
【2】演示，extends Thread
package com.liweixiao.test02;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:买火车票线程
*/
public class BuyTicketThread extends Thread{
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum=10;
//每个窗口都是一个线程对象，每个对象执行的代码放入run方法中
@Override
public void run() {
//每个窗口后面有100个人在排队
for (int i = 1; i <= 100; i++) {
synchronized (BuyTicketThread.class){//必须多个线程用的是同一把锁
if(ticketNum > 0){//大于0才有票
System.out.println("我在"+this.getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
}
}
【3】同步监视器总结：
总结1：认识同步监视器（锁子） ----- synchronized(同步监视器){ }
1)必须是引用数据类型，不能是基本数据类型
2)也可以创建一个专门的同步监视器，没有任何业务含义
3)一般使用共享资源做同步监视器即可
4)在同步代码块中不能改变同步监视器对象的引用
5)尽量不要String和包装类Integer做同步监视器
6)建议使用final修饰同步监视器
总结2：同步代码块的执行过程
1)第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码
2)第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open
3)第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
4)第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open
5)第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）
强调：同步代码块中能发生CPU的切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close）
总结3：其他
1)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
2)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块
13.5.2 方法2：同步方法
【1】代码展示
package com.liweixiao.test04;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class BuyTicketThread implements Runnable{
//一共10张火车票
int ticketNum=10;
//实现run方法
@Override
public void run() {
//此处有1000行代码
for (int i = 1; i <= 100; i++) {
buyTicket();
}
//此处有1000行代码
}
public synchronized void buyTicket(){//锁住的是this
if(ticketNum>0){
System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
package com.liweixiao.test02;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:买火车票线程
*/
public class BuyTicketThread extends Thread{
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum=10;
//每个窗口都是一个线程对象，每个对象执行的代码放入run方法中
@Override
public void run() {
//每个窗口后面有100个人在排队
for (int i = 1; i <= 100; i++) {
buyTicket();
}
}
public static synchronized void buyTicket(){//锁住的 同步监视器：BuyTicketThread.class
if(ticketNum > 0){//大于0才有票
System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张车票");
}
}
}
【2】总结
总结1：
多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。
咱们的锁一般都是引用数据类型的。
目的：解决了线程安全问题。
总结2：关于同步方法
- 不要将run()定义为同步方法
- 非静态同步方法的同步监视器是this
静态同步方法的同步监视器是 类名.class 字节码信息对象 - 同步代码块的效率要高于同步方法
原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部 - 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块
13.5.3 方法3：lock锁（重点）
【1】Lock锁引入
JDK1.5后新增新一代的线程同步方式：Lock锁
与采用synchronized相比，lock可提供多种锁方案，更灵活
synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。
但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。
【2】代码展示
package com.liweixiao.test04;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author:LiWeixiao
* @date:2023/2/10
* @description:
*/
public class BuyTicketThread implements Runnable{
//一共10张火车票
int ticketNum=10;
//拿来一把锁
Lock lock=new ReentrantLock();
//实现run方法
@Override
public void run() {
//此处有1000行代码
for (int i = 1; i <= 100; i++) {
//打开锁
lock.lock();
try {
if(ticketNum>0){
System.out.println("我在"+Thread.currentThread().getName()+"买到了第"+ ticketNum-- +"张车票");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭锁，即时有异常，这个锁也可以得到释放
lock.unlock();
}
}
//此处有1000行代码
}
}
【3】Lock和synchronized的区别
1.Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
2.Lock只有代码块锁，synchronized有代码块锁和方法锁
3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
【4】优先使用顺序：
Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）
13.5.4 线程同步的优缺点
【1】对比：
线程安全，效率低
线程不安全，效率高
【2】可能造成死锁：
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
【3】代码演示：死锁
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(),o2 = new Object();
public void run(){
System.out.println("flag=" + flag);
// 当flag==1锁住o1
if (flag == 1) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
// 只要锁住o2就完成
synchronized (o2) {
System.out.println("2");
}
}
}
// 如果flag==0锁住o2
if (flag == 0) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
// 只要锁住o1就完成
synchronized (o1) {
System.out.println("3");
}
}
}
}
public static void main(String[] args) {
// 实例2个线程类
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
// 开启2个线程
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
【4】解决方法： 减少同步资源的定义，避免嵌套同步
13.6 线程通信的引入
应用场景：生产者和消费者
代码：
1.商品，属性：品牌，名字
2.线程1，生产者
3.线程2，消费者
13.6.1 分解1
出现问题：
1.生产者和消费者没有交替输出，没有通信
2.打印数据错乱，没有同步
代码展示
package com.liweixiao.test10;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Product {
//属性
private String brand;//品牌
private String name;//名字
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.liweixiao.test10;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:生产者线程
*/
public class ProducerThread extends Thread{
//共享商品
private Product p;
public ProducerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//生产10个商品，i是生产的次数
if(i%2 ==0){
//生产费列罗巧克力
p.setBrand("费列罗");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setName("巧克力");
}else {
//生产哈尔滨啤酒
p.setBrand("哈尔滨");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setName("啤酒");
}
System.out.println("生产者生产了"+p.getBrand()+"---"+p.getName());
}
}
}
package com.liweixiao.test10;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class CustomerThread extends Thread{
//共享商品
private Product p;
public CustomerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//i是消费次数
System.out.println("消费者消费了"+p.getBrand()+"---"+p.getName());
}
}
}
package com.liweixiao.test10;
import java.util.Properties;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Test {
public static void main(String[] args) {
//共享的商品
Product p = new Product();
//创建生产者和消费者
ProducerThread pt = new ProducerThread(p);
CustomerThread ct = new CustomerThread(p);
pt.start();
ct.start();
}
}
13.6.2 分解2，解决错乱
【1】利用同步代码块
package com.liweixiao.test10;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:生产者线程
*/
public class ProducerThread extends Thread{
//共享商品
private Product p;
public ProducerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//生产10个商品，i是生产的次数
synchronized (p){
if(i%2 ==0){
//生产费列罗巧克力
p.setBrand("费列罗");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setName("巧克力");
}else {
//生产哈尔滨啤酒
p.setBrand("哈尔滨");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setName("啤酒");
}
System.out.println("生产者生产了"+p.getBrand()+"---"+p.getName());
}
}
}
}
package com.liweixiao.test10;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class CustomerThread extends Thread{
//共享商品
private Product p;
public CustomerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//i是消费次数
synchronized (p){
System.out.println("消费者消费了"+p.getBrand()+"---"+p.getName());
}
}
}
}
【2】利用同步方法
package com.liweixiao.test11;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Product {
//属性
private String brand;//品牌
private String name;//名字
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//生产商品
public synchronized void setProduct(String brand,String name){
this.brand=brand;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name=name;
System.out.println("生产者生产了"+this.getBrand()+"---"+this.getName());
}
//消费商品
public synchronized void getProduct(){
System.out.println("消费者消费了"+this.getBrand()+"---"+this.getName());
}
}
package com.liweixiao.test11;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:生产者线程
*/
public class ProducerThread extends Thread{
//共享商品
private Product p;
public ProducerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//生产10个商品，i是生产的次数
if(i%2 ==0){
p.setProduct("费列罗","巧克力");
}else {
p.setProduct("哈尔滨","啤酒");
}
}
}
}
package com.liweixiao.test11;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class CustomerThread extends Thread{
//共享商品
private Product p;
public CustomerThread(Product p) {
this.p = p;
}
@Override
public void run() {
for (int i = 1; i <=10 ; i++) {//i是消费次数
p.getProduct();
}
}
}
13.6.3 分解3，解决交替输出
【代码】
package com.liweixiao.test11;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Product {
//属性
private String brand;//品牌
private String name;//名字
//引入一个灯：true红色，false绿色
boolean flag=false;//默认情况下没有商品，让生产者先生产
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//生产商品
public synchronized void setProduct(String brand,String name){
if(flag==true){//灯是红色，有商品，不生产
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//灯是绿色的，生产
this.brand=brand;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name=name;
System.out.println("生产者生产了"+this.getBrand()+"---"+this.getName());
//生产后
flag=true;
//告诉消费
notify();
}
//消费商品
public synchronized void getProduct(){
if(flag == false){//没有商品，等待生产
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有商品，消费
System.out.println("消费者消费了"+this.getBrand()+"---"+this.getName());
//灯变色
flag=false;
//通知生产
notify();
}
}
【原理】
以上图片来自网络
注意：wait方法和notify方法 是必须放在同步方法或者同步代码块中才生效的 （因为在同步的基础上进行线程的通信才是有效的）
注意：sleep和wait的区别：sleep进入阻塞状态没有释放锁，wait进入阻塞状态但是同时释放了锁
【线程生命周期完整图】
13.6.4 Lock锁情况下的线程通信
package com.liweixiao.test12;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author:LiWeixiao
* @date:2023/2/11
* @description:
*/
public class Product {
//属性
private String brand;//品牌
private String name;//名字
//声明一个lock锁
Lock lock=new ReentrantLock();
//搞一个生产者的等待队列
Condition productCondition=lock.newCondition();
//搞一个消费者的等待队列
Condition consumeCondition=lock.newCondition();
//引入一个灯：true红色，false绿色
boolean flag=false;//默认情况下没有商品，让生产者先生产
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//生产商品
public void setProduct(String brand,String name){
lock.lock();
try {
if(flag==true){//灯是红色，有商品，不生产
try {
//wait();
//生产者阻塞，生产者进入等待队列中
productCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//灯是绿色的，生产
this.brand=brand;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name=name;
System.out.println("生产者生产了"+this.getBrand()+"---"+this.getName());
//生产后
flag=true;
//告诉消费
//notify();
//唤醒消费者线程池
consumeCondition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//消费商品
public void getProduct(){
lock.lock();
try {
if(flag == false){//没有商品，等待生产
try {
//wait();
//消费者等待，消费者线程进入等待队列
consumeCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有商品，消费
System.out.println("消费者消费了"+this.getBrand()+"---"+this.getName());
//灯变色
flag=false;
//通知生产
//notify();
//唤醒生产者线程池
productCondition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition是在Java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。
它的更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition
一个Condition包含一个等待队列。一个Lock可以产生多个Condition，所以可以有多个等待队列。
在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而Lock（同步器）拥有一个同步队列和多个等待队列。
Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的；而Condition是需要与"互斥锁"/"共享锁"捆绑使用的。
调用Condition的await()、signal()、signalAll()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用
· Conditon中的await()对应Object的wait()；
· Condition中的signal()对应Object的notify()；
· Condition中的signalAll()对应Object的notifyAll()。
void await() throws InterruptedException
造成当前线程在接到信号或被中断之前一直处于等待状态。
与此 Condition 相关的锁以原子方式释放，并且出于线程调度的目的，将禁用当前线程，且在发生以下四种情况之一 以前，当前线程将一直处于休眠状态：
· 其他某个线程调用此 Condition 的 signal() 方法，并且碰巧将当前线程选为被唤醒的线程；或者
· 其他某个线程调用此 Condition 的 signalAll() 方法；或者
· 其他某个线程中断当前线程，且支持中断线程的挂起；或者
· 发生“虚假唤醒”
在所有情况下，在此方法可以返回当前线程之前，都必须重新获取与此条件有关的锁。在线程返回时，可以保证它保持此锁。
void signal()
唤醒一个等待线程。
如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。
void signalAll()
唤醒所有等待线程。
如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁。
浙公网安备 33010602011771号