多线程学习
程序、进程和线程
【1】程序，进程，线程
- 程序（program）:是为完成特定任务、某一种语言编写的一组指令的集合，是一段静态的代码。（程序是静态的）
- 进程（process）：是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。（进程是动态的）是一个动的过程，进程的生命周期：有它自身的产生、存在和消亡的过程
- 线程（Thread），进程可经一部细化为线程，是一个程序内部的一条执行路径。
若一个进程同一时间并行执行多个线程，就是支持多线程的。
【2】单核CPU与多核CPU的任务执行：
- 早期电脑的单核CPU在执行的时候是按照时间片执行的，同一时间片只能执行一个线程，因为时间片时间特别端，感受到的就是“同时”执行多个线程，实际这个多线程是一种假象
- 多核CPU的时候，才真正意义上做到一个时间片多线程同时进行---》多线程发挥了最好的效率---》真正的同时执行---》真正的多线程
【3】并行和并发
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）
创建进程的三种方式
第一种：继承Thread类
【1】在学习多线程之前，以前的代码是单线程吗？不是的，代码也是三个线程同时执行的。
【2】现在我想自己制造多线程---》怎么创建线程？？
线程类--》线程对象
- 想要具备多线程能力，必须继承Thread类,才具备了争抢资源的能力。
- 必须是重写Thread类中的run()方法，并且将线程的任务/逻辑写在run()方法中。
- 想要在主方法中创建子线程，必须使用start()方法启动线程。
- 在主方法中直接调用run()方法，只会被当做一个普通方法被执行。
package com.xmyg.ThreadTest01;
/**
* @Author Chou
* @Date 2021/5/3 21:27
* @Version 1.0
* 想要具备多线程能力，必须继承Thread类,才具备了争抢资源的能力
*/
public class TestThread extends Thread{
/**
* 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底到底是啥？这个任务要放在方法中
* 但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法
* 然后线程的任务/逻辑写在run方法中
*/
@Override
public void run() {
// 输出1-10
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
}
在下面的Test方法中，主方法先按顺序执行了第一个for循环，执行完毕之后创建一个子线程开始执行子线程的run()方法，同时主线程继续执行第二个for循环。
package com.xmyg.ThreadTest01;
/**
* @Author Chou
* @Date 2021/5/3 21:40
* @Version 1.0
*/
public class Test {
public static void main(String[] args) {
//主线程也输出十个数
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类中的方法
//主线程也输出十个数，代码下移
for (int i = 1; i <= 10; i++) {
System.out.println("main2----"+i);
}
}
}
设置和读取线程的名字
【1】通过setName()，getName()方法来进行设置读取：
setName() 设置线程名字
getName() 获取线程名字
Thread.currentThread() 获取当前线程对象
Thread.currentThread().setName("主线程--");
//主线程也输出十个数
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
TestThread tt = new TestThread("子线程");
//tt.setName("子线程1---");
public class TestThread extends Thread{
/**
* 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底到底是啥？这个任务要放在方法中
* 但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法
* 然后线程的任务/逻辑写在run方法中
*/
@Override
public void run() {
// 输出1-10
for (int i = 1; i <= 10; i++) {
System.out.println(this.getName()+i);
}
}
public TestThread(String name){
super(name);
}
}
【2】通过构造器设置线程名字：
public TestThread(String name){
super(name);//通过父类Thread的构造器方法设置线程名称
}
练习题一--买火车票
实现三个售票窗口，总共有十张火车票，启动三个线程来抢票。
package com.xmyg.ThreadTest02;
/**
* @Author Chou
* @Date 2021/5/3 23:18
* @Version 1.0
*/
public class BuyTicketThread extends Thread{
//通过调用父类的构造器方法设置线程名称
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum = 10;//设置静态变量，所有线程共享值
@Override
public void run() {
//每个窗口后面有100人抢票
for (int i = 1; i <=100; i++) {
if (ticketNum > 0) {//对票数进行判断，大于零才能买
System.out.println("我在"+this.getName()+"买到了从北京到武汉的第"+ ticketNum-- +"车票");
}
}
}
}
package com.xmyg.ThreadTest02;
/**
* @Author Chou
* @Date 2021/5/3 23:22
* @Version 1.0
*/
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();
}
}
创建线程的第二种方式
【1】实现Runnable接口
//创建子线程对象
TestThread tt = new TestThread();
//将子线程对象和对象名作为参数创建Runnable子类对象
Thread t = new Thread(tt,"子线程");
//t.setName("子线程");
//调用子类对象的start()方法
t.start();
多线程实现Runnable接口的原理及两种实现方式的区别
实现Runnable的原理
1.看Thread类的构造函数，传递了Runnable接口的引用
2.通过 init()方法找到传递的target给成员变量的target赋值
3.查看run方法，发现run方法中有判断，如果target不为null就会调用Runnalbe接口子类对象的run方法
实现多线程两种方式的区别
1.查看源码的区别
a.继承Thread类：由于子类重写了Thread类的run（）方法，当调用start（）方法时，直接找子类run（）方法
b.实现Runnalbe接口：Thread类构造函数中传入了Runnable的引用，成员变量记住了它，start（）方法调用run（）方法时，内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnalbe的run（），运行时执行的是子类的run（）方法
继承Thread类
好处：可以直接使用Thread类中的方法，代码简单
弊端：如果已经有了父类，就不能用这种方法
实现Runnalbe接口
好处：即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的
弊端：不能直接使用Thread类中的方法，需要先获取到线程对象后，才能得到Thread的方法，代码复杂
练习题二--买火车票 使用实现Runnable()方法创建子线程
BuyTicketThread 子线程类：
package com.xmyg.ThreadTest04;
/**
* @Author Chou
* @Date 2021/5/4 7:50
* @Version 1.0
*/
public class BuyTicketThread implements Runnable{
int ticketNum = 10;
@Override
public void run() {
for (int i = 1; i <= 100 ; i++) {
if (ticketNum > 0){
System.out.println("我在第"+Thread.currentThread().getName()+"窗口买到了第"+ ticketNum-- +"张火车票");
}
}
}
}
Test主方法类：
package com.xmyg.ThreadTest04;
/**
* @Author Chou
* @Date 2021/5/4 7:55
* @Version 1.0
* 使用相同的子线程对象创建子类对象，不需要在线程类中将ticketNum设置为static
*/
public class Test {
public static void main(String[] args) {
uyTicketThread tt = new BuyTicketThread();
Thread t1 = new Thread(tt, "子线程1----");
Thread t2 = new Thread(tt, "子线程2----");
Thread t3 = new Thread(tt, "子线程3----");
t1.start();
t2.start();
t3.start();
}
}
【2】在实际开发中，使用 方式1 继承Thread类 还是 方式2 实现Runnable接口 多呢？ ---》方式2多
- 方式1有Java单继承的局限性，因为继承了Thread类，就不能再继承其他的类了。
- 方式2的共享资源的能力比方式1 的强，不需要在子线程类中加static来修饰变量。
创建线程的第三种方式 实现Callable接口
对比第一种和第二种创建线程的方式发现，无论是第一种继承Thread类方式还是第二种实现Runnable接口方式，都需要有一个run方法，但是run方法存在一下不足：
- 没有返回值
- 不能抛出异常
基于以上不足，在JDK1.5之后出现第三种创建方式，实现Callable接口
实现Callable接口的好处：
- 有返回值
- 能跑出异常
但是也存在缺点：线程的创建比较麻烦
package com.xmyg.ThreadTest05;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Author Chou
* @Date 2021/5/4 11:54
* @Version 1.0
*/
public class TestRandomNum implements Callable<Integer> {
/**
* 1、实现Callable接口可以不带泛型，此时返回值类型位Object类型
* 2、如果带泛型，那么call的返回值就是泛型对应的类型
* 3、从call方法看到：方法有返回值，可以抛出异常
* @return
* @throws Exception
*/
@Override
public Integer call() throws Exception {
return new Random().nextInt(10);//返回10以内的随机数
}
}
class test{
//这是main方法的入口
public static void main(String[] args) throws ExecutionException, InterruptedException {
//定义一个线程对象:
TestRandomNum trn = new TestRandomNum();
//借助FutureTask类，比如获取返回结果
FutureTask ft = new FutureTask(trn);
Thread t = new Thread(ft);
t.start();
//获取线程得到的返回值
Object obj = ft.get();
System.out.println(obj);
}
}
线程的生命周期：
【1】线程开始--》线程消亡
【2】线程经历那些阶段：
线程的常见方法
1.start()：启动当前线程，表面上是调用start方法，实际在调用线程里面的run方法
2.run()：线程类 继承Thread类 或者 实现Runnable接口的时候，都要重写run方法，run方法里面是线程要执行的内容
3.currentThread()：Thread类中一个静态方法：获取当前正在执行的线程
4.setName()：设置线程名字
5.getName()：获取线程名字
其他方法
【1】setPriority()：设置优先级
- 同优先级别的线程，采取的策略是先到先服务
- 如果优先级别高，被CPU调度的概率就高
- 级别：1-10 默认级别为5
package com.xmyg.ThreadTest06;
/**
* @Author Chou
* @Date 2021/5/4 15:48
* @Version 1.0
*/
public class TestThread01 extends Thread{
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}
}
}
class TestThread02 extends Thread{
@Override
public void run() {
for (int i = 20; i <= 30 ; i++) {
System.out.println(i);
}
}
}
class Test{
public static void main(String[] args) {
//创建两个子线程，让这两个子线程争抢资源：
TestThread01 t1 = new TestThread01();
TestThread02 t2 = new TestThread02();
t1.setPriority(1);
t2.setPriority(6);
t1.start();
t2.start();
}
}
【2】join()方法：当一个线程调用了join方法，这个线程就会先被执行，它执行结束之后才可以去执行其余的线程。
注意：必须先start，再调用join才有效。
package com.xmyg.ThreadTest07;
/**
* @Author Chou
* @Date 2021/5/4 17:03
* @Version 1.0
*/
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++) {
if(i == 6){
//创建一个子线程
TestThread tt = new TestThread("子线程");
tt.start();
tt.join();
}
System.out.println("main---"+i);
}
}
}
【3】sleep()方法：人为的阻塞事件
package com.xmyg.ThreadTest08;
/**
* @Author Chou
* @Date 2021/5/4 17:28
* @Version 1.0
*/
public class Test {
public static void main(String[] args) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("00000000000");
}
}
【4】setDaemon()方法：设置守护线程（伴随线程）
将子线程设置位主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了。
package com.xmyg.ThreadTest09;
/**
* @Author Chou
* @Date 2021/5/4 21:33
* @Version 1.0
*/
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();
//主线程中输出1-10的数组：
for (int i = 1; i <= 10 ; i++) {
System.out.println("主线程----"+i);
}
}
}
【5】stop()方法：强迫线程停止执行，不建议使用
package com.xmyg.ThreadTest09;
/**
* @Author Chou
* @Date 2021/5/4 22:03
* @Version 1.0
*/
public class Demo {
public static void main(String[] args) {
for (int i = 1; i <= 100 ; i++) {
if (i == 6){
Thread.currentThread().stop();
}
System.out.println(i);
}
}
}
线程安全问题
【1】出现问题：
- 出现了两个10张票或者三个第十张票
- 出现第0、 -1、 -2张票的请情况
上面的代码出现问题：出现了重票、错票 ---》线程安全硬气的问题
原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。
解决：
在我的程序中，加入“锁”---》加同步---》同步监视器
线程加锁方法一：同步代码块
【1】同步代码块案例一：
package com.xmyg.ThreadTest04;
/**
* @Author Chou
* @Date 2021/5/4 7:50
* @Version 1.0
*/
public class BuyTicketThread implements Runnable{
int ticketNum = 10;
@Override
public void run() {
for (int i = 1; i <= 100 ; i++) {
synchronized (this){//把具有安全隐患的代码锁住即可，如果锁多了就会效率低--》this就是这个锁
if (ticketNum > 0){
System.out.println("我在第"+Thread.currentThread().getName()+"窗口买到了第"+ ticketNum-- +"张火车票");
}
}
}
}
}
【2】同步代码块案例二：
package com.xmyg.ThreadTest02;
/**
* @Author Chou
* @Date 2021/5/3 23:18
* @Version 1.0
*/
public class BuyTicketThread extends Thread{
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum = 10;
@Override
public void run() {
//每个窗口后面有100人抢票
for (int i = 1; i <=100; i++) {
synchronized (BuyTicketThread.class){//此处的锁名称必须定义不能使用this，因为this表示当前对象，但是通过继承Thread类来新建的子线程都是不同的对象，如果使用this会出现每个对象各自拥有一个自己的锁，实际上没有实现多个线程对应一把锁。一般命名为当前对象的字节码文件名
if (ticketNum > 0) {//对票数进行判断，大于零才能买
System.out.println("我在"+this.getName()+"买到了从北京到武汉的第"+ ticketNum-- +"车票");
}
}
}
}
}
【3】同步监视器总结：
总结1：认识同步监视器（锁子） -------- synchronized（同步监视器）{}
- 必须是引用数据类型，不能是基础数据类型
- 也可以创建一个专门的同步监视器，没有任何业务含义
- 一般使用共享资源做同步监视器即可
- 在同步代码块中不能改变同步监视器对象的引用（如下图改变了a的值）
- 尽量不要String和包装类Integer做同步监视器
- 建议使用final修饰同步监视器
总结2：同步代码块的执行过程
- 第一个线程来到同步代码块，发现同步监视器open状态，需要close，然后执行其中的代码
- 第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去CPU，但是没有开锁open
- 第二个线程获取CPU，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
- 第一个线程再次获取CPU，接着执行后续的代码；同步代码块执行完毕，释放锁open
- 第二个线程也再次获取CPU，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，有阻塞状态进入就绪状态，在进入运行状态，重复第一个线程的处理过程（加锁）
强调：同步代码块中能发生CPU的切换吗？能！！！但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧处于close状态）
总结3：其他
- 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法范围其中的任何一个代码块
- 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块
线程加锁方法二：同步方法
【1】代码展示
代码案例一
package com.xmyg.ThreadTest04;
/**
* @Author Chou
* @Date 2021/5/4 7:50
* @Version 1.0
*/
public class BuyTicketThread implements Runnable{
int ticketNum = 10;
@Override
public void run() {
for (int i = 1; i <= 100 ; i++) {
buyTicket();
}
}
public synchronized void buyTicket(){
if (ticketNum > 0){
System.out.println("我在第"+Thread.currentThread().getName()+"窗口买到了第"+ ticketNum-- +"张火车票");
}
}
}
代码案例2
package com.xmyg.ThreadTest02;
/**
* @Author Chou
* @Date 2021/5/3 23:18
* @Version 1.0
*/
public class BuyTicketThread extends Thread{
public BuyTicketThread(String name){
super(name);
}
//一共10张票
static int ticketNum = 10;
@Override
public void run() {
//每个窗口后面有100人抢票
for (int i = 1; i <=100; i++) {
// synchronized (BuyTicketThread.class){
// if (ticketNum > 0) {//对票数进行判断，大于零才能买
// System.out.println("我在"+this.getName()+"买到了从北京到武汉的第"+ ticketNum-- +"车票");
// }
// }
buyTicket();
}
}
public static synchronized void buyTicket(){//增加static声明，锁住的同步监视器为：BuyTicketThread.class
if (ticketNum > 0) {//对票数进行判断，大于零才能买
System.out.println("我在"+Thread.currentThread().getName()+"买到了从北京到武汉的第"+ ticketNum-- +"车票");
}
}
}
【2】总结：
总结1：
多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。）
锁一般都是引用数据类型的。
目的：解决了线程安全问题。
总结2：关于同步方法
-
不要将run()定义为同步方法
-
非静态同步方法的同步监视器是this，静态同步方法的同步监视器是 类名.class 字节码信息对象
-
同步代码块的效率要高于同步方法
原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却在方法的内部
-
同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块。
线程加锁方法三：Lock锁
【1】Lock锁的引入
JDK1.5后新增的新一代的线程同步方式：Lock锁
与采用synchronized相比，lock可提供多种锁方案，更灵活
synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的。是虚拟机级别的。
但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这种方式更加林火，表现出来的性能优于之前的方式。
【2】代码演示
package com.xmyg.ThreadTest04;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author Chou
* @Date 2021/5/4 7:50
* @Version 1.0
*/
public class BuyTicketThread implements Runnable{
int ticketNum = 10;
//拿来一把锁,lock是接口，所以创建对象时必须创建它的实现类，以下以ReentrantLock()为例;接口=实现类 可以使用不同的实现类 扩展性较强
Lock lock =new ReentrantLock();
@Override
public void run() {
for (int i = 1; i <= 100 ; i++) {
//打开锁
lock.lock();
// 增加try 防止异常出现之后锁没有正常关闭
try {
if (ticketNum > 0){
System.out.println("我在第"+Thread.currentThread().getName()+"窗口买到了第"+ ticketNum-- +"张火车票");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
lock.unlock();
}
}
}
}
【3】Lock和synchronized的区别
- Lock是显式锁（手动开启和关闭锁，注意千万别忘记关锁），synchronized是隐式锁
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
【4】优先使用顺序：
Lock---------同步代码块（已经进入了方法体，分配了相应资源）--------同步方法（在方法体之外）
线程同步的优缺点
【1】对比：
线程安全，效率低
线程不安全，效率高
【2】可能造成死锁：
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
【3】代码演示：
package com.xmyg.ThreadTest09;
/**
* @Author Chou
* @Date 2021/5/8 17:08
* @Version 1.0
*/
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(), o2 = new Object();
@Override
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.printf("2");
}
}
}
//如果flag==0锁住o2
if(flag == 0){
synchronized (o2){
try {
Thread.sleep(500);
} catch (Exception e){
e.printStackTrace();
}
synchronized (o1){
System.out.println("3");
}
}
}
}
public static void main(String[] args) {
//实现两个线程类
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
//开启两个线程
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
【4】解决方法：
减少同步资源的定义，避免嵌套同步
线程通信问题
应用场景：生产者和消费者问题
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止
代码：
- 商品： 属性：品牌、名字
- 线程1：生产者
- 线程2：消费者
功能分解：
出现的问题：
- 生产者和消费者没有交替输出
- 打印数据错乱---没有加同步
代码展示：
商品类：
package com.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 18:57
* @Version 1.0
*/
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.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 18:58
* @Version 1.0
*/
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++) {//生产是个商品
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.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 19:14
* @Version 1.0
*/
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++) {//消费次数
System.out.println("消费者消费了：" + p.getBrand() + "---" + p.getName());
}
}
}
测试主类：
package com.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 19:17
* @Version 1.0
*/
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();
}
}
分解二：解决打印错乱的问题
【1】利用同步代码块解决问题
商品类和测试主类与上一步骤相同
生产者类：
package com.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 18:58
* @Version 1.0
*/
public class ProducerThread extends Thread{
//共享的商品
private Product p;
public ProducerThread(Product p){
this.p = p;
}
@Override
public void run() {
synchronized (p){
for (int i = 1; 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.xmyg.ThreadTest10;
/**
* @Author Chou
* @Date 2021/5/8 19:14
* @Version 1.0
*/
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++) {//消费次数
synchronized (p){
System.out.println("消费者消费了：" + p.getBrand() + "---" + p.getName());
}
}
}
}
【2】利用同步方法解决问题，将方法提取到商品类中然后添加方法锁
商品类：
package com.xmyg.ThreadTest11;
/**
* @Author Chou
* @Date 2021/5/8 18:57
* @Version 1.0
*/
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.setBrand(brand);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setName(name);
//将生产信息打印出来
System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
}
public synchronized void getProduct(){
System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
}
}
生产者类：
package com.xmyg.ThreadTest11;
/**
* @Author Chou
* @Date 2021/5/8 18:58
* @Version 1.0
*/
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++) {//生产是个商品
if (i % 2 == 0){
p.setProduct("费列罗","巧克力");
} else {
p.setProduct("哈尔滨","啤酒");
}
}
}
}
消费者类：
package com.xmyg.ThreadTest11;
/**
* @Author Chou
* @Date 2021/5/8 19:14
* @Version 1.0
*/
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++) {//消费次数
p.getProduct();
}
}
}
分解三：线程通信
【1】原理
【代码】
商品类
package com.xmyg.ThreadTest11;
/**
* @Author Chou
* @Date 2021/5/8 18:57
* @Version 1.0
*/
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.setBrand(brand);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setName(name);
//将生产信息打印出来
System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
//生产完之后，灯变成红色：
flag = true;
//告诉消费者来消费
notify();
}
public synchronized void getProduct(){
if (!flag){// flag == false 没有商品，等待生产者生产
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有商品的情况下进行消费
System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
//消费完之后灯变色
flag = false;
//通知等待的线程进入就绪
notify();
}
}
【原理】
在Java对象中，有两种池
锁池-----------------------------------------synchronized
等待池----------------------------------------wait() notify() notifyAll()
如果一个线程调用了某个对象的wait方法，那么该线程进入到该对象的等待池中（并且已经将锁释放）
如果未来的某一时刻，另外一个线程调用了相同对象的notify方法或notifyAll方法，那么该等待池中的线程就会被唤醒，然后进入到对象的锁池里面去获取该对象的锁，如果获取锁成功后，那么该线程就会严重wait方法之后的路径继续执行。注意是沿着wait方法之后，这也是为什么上面代码中if后面没有接else的原因。
注意：wait方法和notify方法必须放在同步方法或者同步代码块中才能生效
sleep和wait的区别：sleep进入阻塞状态没有释放锁，wait进入阻塞状态同时释放锁。
wait和notify可参考 https://www.cnblogs.com/fenjyang/p/11603229.html
Lock锁情况下的线程通信
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来模拟线程间协作。
它的更强大之处在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition
一个Condition包含一个等待队列。一个Lock可以产生多个Condition，所以可以有多个等待队列。
在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而Lock（同步器）拥有一个同步队列和多个等待队列。
Object中的wait(),notify(),notifyAll()方法是和“同步锁”（synchronized关键字）捆绑使用的；而Condition是需要与“互斥锁/共享锁”捆绑使用的。
调用Condition的await()、signal()、signalAll()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock()之间才可以使用
- Condition中的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返回之前，每个线程都必须重新获取锁。
package com.xmyg.ThreadTest12;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author Chou
* @Date 2021/5/8 18:57
* @Version 1.0
*/
public class Product {
//品牌
private String brand;
//名字
private String name;
//声明一个lock锁
Lock lock = new ReentrantLock();
//新增生产者的等待队列：
Condition produceCondition = 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();
produceCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//灯是绿色的，就生产：
//生产费列罗巧克力
this.setBrand(brand);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setName(name);
//将生产信息打印出来
System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
//生产完之后，灯变成红色：
flag = true;
//告诉消费者来消费
// notify();
consumeCondition.signal();
}finally {
lock.unlock();
}
}
public void getProduct(){
lock.lock();
try {
if (!flag){// flag == false 没有商品，等待生产者生产
try {
consumeCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有商品的情况下进行消费
System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
//消费完之后灯变色
flag = false;
//通知等待的线程进入就绪
// notify();
produceCondition.signal();
}finally {
lock.unlock();
}
}
}