java-多线程
2023-12-22 19:38:16
程序，进程，线程
【1】程序，进程，线程
?程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码。 （程序是静态的）
?进程(process)：是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。 （进程是动态的）是一个动的过程 ，进程的生命周期 ?: ?有它自身的产生、存在和消亡的过程?
?线程(thread)，进程可进一步细化为线程， 是一个程序内部的一条执行路径。
? 若一个进程同一时间并行执行多个线程，就是支持多线程的。
【2】单核CPU与多核CPU的任务执行：
【3】并行和并发：
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）
创建线程的三种方式
第一种：继承Thread类
【1】在学习多线程一章之前，以前的代码是单线程的吗？不是，以前也是有三个线程同时执行的。
【2】现在我想自己制造多线程---》创建线程 ？？
线程类--》线程对象
1.package com.msb.test01;
2.
3./**
4. * @author : msb-zhaoss
5. * 线程类叫：TestThread，不是说你名字中带线程单词你就具备多线程能力了（争抢资源能力）
6. * 现在想要具备能力，继承一个类：Thread，具备了争抢资源的能力
7. */
8.public class TestThread extends Thread{
9. /*
10. 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底是啥？这个任务你要放在方法中
11. 但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法
12. 然后线程的任务/逻辑写在run方法中
13. */
14. @Override
15. public void run() {
16. //输出1-10
17. for (int i = 1; i <= 10 ; i++) {
18. System.out.println(i);
19. }
20. }
21.}1.package com.msb.test01;
2.
3./**
4. * @author : msb-zhaoss
5. * 测试类
6. */
7.public class Test {
8. //这是main方法，程序的入口
9. public static void main(String[] args) {
10. //主线程中也要输出十个数：
11. for (int i = 1; i <= 10 ; i++) {
12. System.out.println("main1-----"+i);
13. }
14.
15. //制造其他线程，要跟主线程争抢资源：
16. //具体的线程对象：子线程
17. TestThread tt = new TestThread();
18. //tt.run();//调用run方法，想要执行线程中的任务 -->这个run方法不能直接调用，直接调用就会被当做一个普通方法
19. //想要tt子线程真正起作用比如要启动线程：
20. tt.start();//start()是Thread类中的方法
21.
22. //主线程中也要输出十个数：
23. for (int i = 1; i <= 10 ; i++) {
24. System.out.println("main2-----"+i);
25. }
26. }
27.}
28.运行结果：
设置读取线程名字
【1】setName,getName方法来进行设置读取：
1.package com.msb.test01;
2.
3./**
4. * @author : msb-zhaoss
5. * 线程类叫：TestThread，不是说你名字中带线程单词你就具备多线程能力了（争抢资源能力）
6. * 现在想要具备能力，继承一个类：Thread，具备了争抢资源的能力
7. */
8.public class TestThread extends Thread{
9. /*
10. 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底是啥？这个任务你要放在方法中
11. 但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法
12. 然后线程的任务/逻辑写在run方法中
13. */
14. @Override
15. public void run() {
16. //输出1-10
17. for (int i = 1; i <= 10 ; i++) {
18. System.out.println(this.getName()+i);
19. }
20. }
21.}
22.1.package com.msb.test01;
2.
3./**
4. * @author : msb-zhaoss
5. * 测试类
6. */
7.public class Test {
8. //这是main方法，程序的入口
9. public static void main(String[] args) {
10. //给main方法这个主线程设置名字：
11. //Thread.currentThread()作用获取当前正在执行的线程
12. Thread.currentThread().setName("主线程");
13. //主线程中也要输出十个数：
14. for (int i = 1; i <= 10 ; i++) {
15. System.out.println(Thread.currentThread().getName()+"1-------"+i);
16. }
17.
18. //制造其他线程，要跟主线程争抢资源：
19. //具体的线程对象：子线程
20. TestThread tt = new TestThread();
21. tt.setName("子线程");
22. //tt.run();//调用run方法，想要执行线程中的任务 -->这个run方法不能直接调用，直接调用就会被当做一个普通方法
23. //想要tt子线程真正起作用比如要启动线程：
24. tt.start();//start()是Thread类中的方法
25.
26. //主线程中也要输出十个数：
27. for (int i = 1; i <= 10 ; i++) {
28. System.out.println(Thread.currentThread().getName()+"2-------"+i);
29. }
30. }
31.}【2】通过构造器设置 名字：
1.package com.msb.test01;
2.
3./**
4. * @author : msb-zhaoss
5. * 线程类叫：TestThread，不是说你名字中带线程单词你就具备多线程能力了（争抢资源能力）
6. * 现在想要具备能力，继承一个类：Thread，具备了争抢资源的能力
7. */
8.public class TestThread extends Thread{
9. public TestThread(String name){
10. super(name);//调用父类的有参构造器
11. }
12. /*
13. 一会线程对象就要开始争抢资源了，这个线程要执行的任务到底是啥？这个任务你要放在方法中
14. 但是这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法
15. 然后线程的任务/逻辑写在run方法中
16. */
17. @Override
18. public void run() {
19. //输出1-10
20. for (int i = 1; i <= 10 ; i++) {
21. System.out.println(this.getName()+i);
22. }
23. }
24.}
25.习题：买火车票
【1】原理：每个窗口都是一个线程对象：
【2】代码：
1.package com.msb.test02;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class BuyTicketThread extends Thread {
7. public BuyTicketThread(String name){
8. super(name);
9. }
10. //一共10张票：
11. static int ticketNum = 10;//多个对象共享10张票
12. //每个窗口都是一个线程对象：每个对象执行的代码放入run方法中
13. @Override
14. public void run() {
15. //每个窗口后面有100个人在抢票：
16. for (int i = 1; i <= 100 ; i++) {
17. if(ticketNum > 0){//对票数进行判断，票数大于零我们才抢票
18. System.out.println("我在"+this.getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
19. }
20. }
21. }
22.}
23.1.package com.msb.test02;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Test {
7. public static void main(String[] args) {
8. //多个窗口抢票：三个窗口三个线程对象：
9. BuyTicketThread t1 = new BuyTicketThread("窗口1");
10. t1.start();
11. BuyTicketThread t2 = new BuyTicketThread("窗口2");
12. t2.start();
13. BuyTicketThread t3 = new BuyTicketThread("窗口3");
14. t3.start();
15.
16. }
17.}第二种：实现Runnable接口
【1】代码
1.package com.msb.test03;
2.
3./**
4. * @author : msb-zhaoss
5. * TestThread实现了这个接口，才会变成一个线程类
6. */
7.public class TestThread implements Runnable{
8. @Override
9. public void run() {
10. //输出1-10数字：
11. for (int i = 1; i <= 10 ; i++) {
12. System.out.println(Thread.currentThread().getName()+"----"+i);
13. }
14. }
15.}
16.1.package com.msb.test03;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Test {
7. public static void main(String[] args) {
8. //创建子线程对象：
9. TestThread tt = new TestThread();
10. Thread t = new Thread(tt,"子线程");
11. t.start();
12.
13. //主线程里面也是打印1-10数字：
14. for (int i = 1; i <= 10 ; i++) {
15. System.out.println(Thread.currentThread().getName()+"---"+i);
16. }
17. }
18.}运行结果：
习题：买火车票
【1】代码：
1.package com.msb.test04;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class BuyTicketThread implements Runnable {
7. int ticketNum = 10;
8. @Override
9. public void run() {
10. for (int i = 1; i <= 100 ; i++) {
11. if(ticketNum > 0){
12. System.out.println("我在"+Thread.currentThread().getName()+"买到了北京到哈尔滨的第" + ticketNum-- + "张车票");
13. }
14. }
15. }
16.}
17.1.package com.msb.test04;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Test {
7. //这是main方法，程序的入口
8. public static void main(String[] args) {
9. //定义一个线程对象：
10. BuyTicketThread t = new BuyTicketThread();
11. //窗口1买票：
12. Thread t1 = new Thread(t,"窗口1");
13. t1.start();
14. //窗口2买票：
15. Thread t2 = new Thread(t,"窗口2");
16. t2.start();
17. //窗口3买票：
18. Thread t3 = new Thread(t,"窗口3");
19. t3.start();
20. }
21.}
22.【2】实际开发中，方式1 继承Thread类 ? 还是 ?方式2 实现Runnable接口这种方式多呢？--》方式2
（1）方式1的话有 Java单继承的局限性，因为继承了Thread类，就不能再继承其它的类了
（2）方式2的共享资源的能力也会强一些，不需要非得加个static来修饰
【3】Thread类 Runnable接口 有联系吗？
第三种：实现Callable接口
对比第一种和第二种创建线程的方式发现，无论第一种继承Thread类的方式还是第二种实现Runnable接口的方式，都需要有一个run方法，
但是这个run方法有不足：
（1）没有返回值
（2）不能抛出异常
基于上面的两个不足，在JDK1.5以后出现了第三种创建线程的方式：实现Callable接口：
实现Callable接口好处：（1）有返回值 ?（2）能抛出异常
缺点：线程创建比较麻烦
1.package com.msb.test05;
2.
3.import java.util.Random;
4.import java.util.concurrent.Callable;
5.import java.util.concurrent.ExecutionException;
6.import java.util.concurrent.FutureTask;
7.
8./**
9. * @author : msb-zhaoss
10. */
11.public class TestRandomNum implements Callable<Integer> {
12. /*
13. 1.实现Callable接口，可以不带泛型，如果不带泛型，那么call方式的返回值就是Object类型
14. 2.如果带泛型，那么call的返回值就是泛型对应的类型
15. 3.从call方法看到：方法有返回值，可以跑出异常
16. */
17. @Override
18. public Integer call() throws Exception {
19. return new Random().nextInt(10);//返回10以内的随机数
20. }
21.}
22.
23.class Test{
24. //这是main方法，程序的入口
25. public static void main(String[] args) throws ExecutionException, InterruptedException {
26. //定义一个线程对象：
27. TestRandomNum trn = new TestRandomNum();
28. FutureTask ft = new FutureTask(trn);
29. Thread t = new Thread(ft);
30. t.start();
31. //获取线程得到的返回值：
32. Object obj = ft.get();
33. System.out.println(obj);
34. }
35.}线程的生命周期
【1】线程声明周期：线程开始--》线程消亡
【2】线程经历哪些阶段：
线程常见方法
（1）start() : ?启动当前线程，表面上调用start方法，实际在调用线程里面的run方法
（2）run() : 线程类 继承 Thread类 或者 实现Runnable接口的时候，都要重新实现这个run方法，run方法里面是线程要执行的内容
（3）currentThread :Thread类中一个静态方法：获取当前正在执行的线程
（4）setName 设置线程名字
（5）getName 读取线程名字
设置优先级
【1】同优先级别的线程，采取的策略就是先到先服务，使用时间片策略
【2】如果优先级别高，被CPU调度的概率就高
【3】级别：1-10 ? 默认的级别为5
【4】代码：
1.package com.msb.test06;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class TestThread01 extends Thread {
7. @Override
8. public void run() {
9. for (int i = 1; i <= 10; i++) {
10. System.out.println(i);
11. }
12. }
13.}
14.
15.class TestThread02 extends Thread{
16. @Override
17. public void run() {
18. for (int i = 20; i <= 30 ; i++) {
19. System.out.println(i);
20. }
21. }
22.}
23.
24.class Test{
25. //这是main方法，程序的入口
26. public static void main(String[] args) {
27. //创建两个子线程，让这两个子线程争抢资源：
28. TestThread01 t1 = new TestThread01();
29. t1.setPriority(10);//优先级别高
30. t1.start();
31.
32. TestThread02 t2 = new TestThread02();
33. t2.setPriority(1);//优先级别低
34. t2.start();
35. }
36.}
37.join
join方法：当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。
注意：必须先start，再join才有效。?
1.package com.msb.test07;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class TestThread extends Thread {
7. public TestThread(String name){
8. super(name);
9. }
10. @Override
11. public void run() {
12. for (int i = 1; i <= 10 ; i++) {
13. System.out.println(this.getName()+"----"+i);
14. }
15. }
16.}
17.
18.class Test{
19. //这是main方法，程序的入口
20. public static void main(String[] args) throws InterruptedException {
21. for (int i = 1; i <= 100 ; i++) {
22. System.out.println("main-----"+i);
23. if(i == 6){
24. //创建子线程：
25. TestThread tt = new TestThread("子线程");
26. tt.start();
27. tt.join();//“半路杀出个程咬金”
28. }
29.
30. }
31. }
32.}
33.sleep
【1】sleep : 人为的制造阻塞事件
1.public class Test01 {
2. //这是main方法，程序的入口
3. public static void main(String[] args) {
4. try {
5. Thread.sleep(3000);
6. } catch (InterruptedException e) {
7. e.printStackTrace();
8. }
9. System.out.println("00000000000000");
10. }
11.}
12.【2】案例：完成秒表功能：
1.package com.msb.test08;
2.
3.import javafx.scene.input.DataFormat;
4.
5.import java.text.DateFormat;
6.import java.text.SimpleDateFormat;
7.import java.util.Date;
8.
9./**
10. * @author : msb-zhaoss
11. */
12.public class Test02 {
13. //这是main方法，程序的入口
14. public static void main(String[] args) {
15. //2.定义一个时间格式：
16. DateFormat df = new SimpleDateFormat("HH:mm:ss");
17. while(true){
18. //1.获取当前时间：
19. Date d = new Date();
20. //3.按照上面定义的格式将Date类型转为指定格式的字符串：
21. System.out.println(df.format(d));
22. try {
23. Thread.sleep(1000);
24. } catch (InterruptedException e) {
25. e.printStackTrace();
26. }
27. }
28. }
29.}
30.setDaemon
【1】设置伴随线程
将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
案例：皇上 --》驾崩 ---》妃子陪葬
1.package com.msb.test09;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class TestThread extends Thread {
7. @Override
8. public void run() {
9. for (int i = 1; i <= 1000 ; i++) {
10. System.out.println("子线程----"+i);
11. }
12. }
13.}
14.class Test{
15. //这是main方法，程序的入口
16. public static void main(String[] args) {
17. //创建并启动子线程：
18. TestThread tt = new TestThread();
19. tt.setDaemon(true);//设置伴随线程 注意：先设置，再启动
20. tt.start();
21.
22. //主线程中还要输出1-10的数字：
23. for (int i = 1; i <= 10 ; i++) {
24. System.out.println("main---"+i);
25. }
26. }
27.}结果：
stop
1.package com.msb.test09;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Demo {
7. //这是main方法，程序的入口
8. public static void main(String[] args) {
9. for (int i = 1; i <= 100 ; i++) {
10. if(i == 6){
11. Thread.currentThread().stop();//过期方法，不建议使用
12. }
13. System.out.println(i);
14. }
15. }
16.}
17.线程安全问题
【1】出现问题：
（1）出现了两个10张票或者3个10张票：
（2）出现0，-1，-2可能：
上面的代码出现问题：出现了 重票，错票，---》 线程安全引起的问题?
原因：多个线程，在争抢资源的过程中，导致共享的资源出现问题。一个线程还没执行完，另一个线程就参与进来了，开始争抢。?
解决：
在我的程序中，加入“锁” --》加同步 ?--》同步监视器
方法1：同步代码块
【1】同步代码块演示1：
1.package com.msb.test04;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class BuyTicketThread implements Runnable {
7. int ticketNum = 10;
8. @Override
9. public void run() {
10. //此处有1000行代码
11. for (int i = 1; i <= 100 ; i++) {
12. synchronized (this){//把具有安全隐患的代码锁住即可，如果锁多了就会效率低 --》this就是这个锁
13. if(ticketNum > 0){
14. System.out.println("我在"+Thread.currentThread().getName()+"买到了北京到哈尔滨的第" + ticketNum-- + "张车票");
15. }
16. }
17. }
18. //此处有1000行代码
19. }
20.}
21.【2】同步代码块演示2：
1.public class BuyTicketThread extends Thread {
2. public BuyTicketThread(String name){
3. super(name);
4. }
5. //一共10张票：
6. static int ticketNum = 10;//多个对象共享10张票
7. //每个窗口都是一个线程对象：每个对象执行的代码放入run方法中
8. @Override
9. public void run() {
10. //每个窗口后面有100个人在抢票：
11. for (int i = 1; i <= 100 ; i++) {
12. synchronized (BuyTicketThread.class){//锁必须多个线程用的是同一把锁！！！
13. if(ticketNum > 0){//对票数进行判断，票数大于零我们才抢票
14. System.out.println("我在"+this.getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
15. }
16. }
17. }
18. }
19.}【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)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块
方法2：同步方法
【1】代码展示：
1.ublic class BuyTicketThread implements Runnable {
2. int ticketNum = 10;
3. @Override
4. public void run() {
5. //此处有1000行代码
6. for (int i = 1; i <= 100 ; i++) {
7. buyTicket();
8. }
9. //此处有1000行代码
10. }
11.
12. public synchronized void buyTicket(){//锁住的是this
13. if(ticketNum > 0){
14. System.out.println("我在"+Thread.currentThread().getName()+"买到了北京到哈尔滨的第" + ticketNum-- + "张车票");
15. }
16. }
17.}1.public class BuyTicketThread extends Thread {
2. public BuyTicketThread(String name){
3. super(name);
4. }
5. //一共10张票：
6. static int ticketNum = 10;//多个对象共享10张票
7. //每个窗口都是一个线程对象：每个对象执行的代码放入run方法中
8. @Override
9. public void run() {
10. //每个窗口后面有100个人在抢票：
11. for (int i = 1; i <= 100 ; i++) {
12. buyTicket();
13. }
14. }
15.
16. public static synchronized void buyTicket(){//锁住的 同步监视器： BuyTicketThread.class
17. if(ticketNum > 0){//对票数进行判断，票数大于零我们才抢票
18. System.out.println("我在"+Thread.currentThread().getName()+"买到了从北京到哈尔滨的第" + ticketNum-- + "张车票");
19. }
20. }
21.
22.}【2】总结：
总结1：
多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。
咱们的锁一般都是引用数据类型的。
目的：解决了线程安全问题。
总结2：关于同步方法
1) 不要将run()定义为同步方法
2) 非静态同步方法的同步监视器是this
? ? 静态同步方法的同步监视器是 类名.class 字节码信息对象
3) 同步代码块的效率要高于同步方法
? ? ?原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部
4)?同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块?
方法3：Lock锁
【1】Lock锁引入：
JDK1.5后新增新一代的线程同步方式:Lock锁
与采用synchronized相比，lock可提供多种锁方案，更灵活
synchronized是Java中的关键字，这个关键字的识别是靠JVM来识别完成的呀。是虚拟机级别的。
但是Lock锁是API级别的，提供了相应的接口和对应的实现类，这个方式更灵活，表现出来的性能优于之前的方式。
【2】代码演示：
1.package com.msb.test04;
2.
3.import java.util.concurrent.locks.Lock;
4.import java.util.concurrent.locks.ReentrantLock;
5.
6./**
7. * @author : msb-zhaoss
8. */
9.public class BuyTicketThread implements Runnable {
10. int ticketNum = 10;
11. //拿来一把锁：
12. Lock lock = new ReentrantLock();//多态 接口=实现类 可以使用不同的实现类
13. @Override
14. public void run() {
15. //此处有1000行代码
16. for (int i = 1; i <= 100 ; i++) {
17. //打开锁：
18. lock.lock();
19. try{
20. if(ticketNum > 0){
21. System.out.println("我在"+Thread.currentThread().getName()+"买到了北京到哈尔滨的第" + ticketNum-- + "张车票");
22. }
23. }catch (Exception ex){
24. ex.printStackTrace();
25. }finally {
26. //关闭锁：--->即使有异常，这个锁也可以得到释放
27. lock.unlock();
28. }
29.
30. }
31. //此处有1000行代码
32. }
33.}
34.【3】?Lock和synchronized的区别
? ? ? ? 1.Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
? ? ? ? 2.Lock只有代码块锁，synchronized有代码块锁和方法锁
? ? ? ? 3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
【4】优先使用顺序：
? ? ? ? Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）
线程同步的优缺点
【1】对比：
线程安全，效率低?
线程不安全，效率高
【2】可能造成死锁：
死锁
>不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
>出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
【3】代码演示：
1.public class TestDeadLock implements Runnable {
2. public int flag = 1;
3. static Object o1 = new Object(),o2 = new Object();
4.
5.
6. public void run(){
7. System.out.println("flag=" + flag);
8. // 当flag==1锁住o1
9. if (flag == 1) {
10. synchronized (o1) {
11. try {
12. Thread.sleep(500);
13. } catch (Exception e) {
14. e.printStackTrace();
15. }
16. // 只要锁住o2就完成
17. synchronized (o2) {
18. System.out.println("2");
19. }
20. }
21. }
22. // 如果flag==0锁住o2
23. if (flag == 0) {
24. synchronized (o2) {
25. try {
26. Thread.sleep(500);
27. } catch (Exception e) {
28. e.printStackTrace();
29. }
30. // 只要锁住o1就完成
31. synchronized (o1) {
32. System.out.println("3");
33. }
34. }
35. }
36. }
37.
38.
39. public static void main(String[] args) {
40. // 实例2个线程类
41. TestDeadLock td1 = new TestDeadLock();
42. TestDeadLock td2 = new TestDeadLock();
43. td1.flag = 1;
44. td2.flag = 0;
45. // 开启2个线程
46. Thread t1 = new Thread(td1);
47. Thread t2 = new Thread(td2);
48. t1.start();
49. t2.start();
50. }
51.}【4】解决方法： 减少同步资源的定义，避免嵌套同步
线程通信问题
应用场景：生产者和消费者问题
假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止
代码结果展示：
代码：
1.商品：属性：品牌 ，名字
2.线程1：生产者
3.线程2：消费者
分解1
出现问题：
1.生产者和消费者没有交替输出
2.打印数据错乱
哈尔滨 - null
费列罗啤酒
哈尔滨巧克力
----没有加同步
代码展示：
1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Product {//商品类
7. //品牌
8. private String brand;
9. //名字
10. private String name;
11. //setter,getter方法；
12.
13. public String getBrand() {
14. return brand;
15. }
16.
17. public void setBrand(String brand) {
18. this.brand = brand;
19. }
20.
21. public String getName() {
22. return name;
23. }
24.
25. public void setName(String name) {
26. this.name = name;
27. }
28.}1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class ProducerThread extends Thread{//生产者线程
7. //共享商品：
8. private Product p;
9.
10. public ProducerThread(Product p) {
11. this.p = p;
12. }
13.
14. @Override
15. public void run() {
16. for (int i = 1; i <= 10 ; i++) {//生产十个商品 i:生产的次数
17. if(i % 2 == 0){
18. //生产费列罗巧克力
19. p.setBrand("费列罗");
20. try {
21. Thread.sleep(100);
22. } catch (InterruptedException e) {
23. e.printStackTrace();
24. }
25. p.setName("巧克力");
26. }else{
27. //生产哈尔滨啤酒
28. p.setBrand("哈尔滨");
29. try {
30. Thread.sleep(100);
31. } catch (InterruptedException e) {
32. e.printStackTrace();
33. }
34. p.setName("啤酒");
35. }
36.
37. //将生产信息做一个打印：
38. System.out.println("生产者生产了：" + p.getBrand() + "---" + p.getName());
39. }
40. }
41.}
42.1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class CustomerThread extends Thread{//消费者线程
7. //共享商品：
8. private Product p;
9.
10. public CustomerThread(Product p) {
11. this.p = p;
12. }
13.
14. @Override
15. public void run() {
16. for (int i = 1; i <= 10 ; i++) {//i:消费次数
17. System.out.println("消费者消费了：" + p.getBrand() + "---" + p.getName());
18. }
19. }
20.}1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Test {
7. //这是main方法，程序的入口
8. public static void main(String[] args) {
9. //共享的商品：
10. Product p = new Product();
11. //创建生产者和消费者线程：
12. ProducerThread pt = new ProducerThread(p);
13. CustomerThread ct = new CustomerThread(p);
14.
15. pt.start();
16. ct.start();
17. }
18.}
19.分解2
【1】利用同步代码块解决问题：
1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class ProducerThread extends Thread{//生产者线程
7. //共享商品：
8. private Product p;
9.
10. public ProducerThread(Product p) {
11. this.p = p;
12. }
13.
14. @Override
15. public void run() {
16. for (int i = 1; i <= 10 ; i++) {//生产十个商品 i:生产的次数
17. synchronized (p){
18. if(i % 2 == 0){
19. //生产费列罗巧克力
20. p.setBrand("费列罗");
21. try {
22. Thread.sleep(100);
23. } catch (InterruptedException e) {
24. e.printStackTrace();
25. }
26. p.setName("巧克力");
27. }else{
28. //生产哈尔滨啤酒
29. p.setBrand("哈尔滨");
30. try {
31. Thread.sleep(100);
32. } catch (InterruptedException e) {
33. e.printStackTrace();
34. }
35. p.setName("啤酒");
36. }
37.
38. //将生产信息做一个打印：
39. System.out.println("生产者生产了：" + p.getBrand() + "---" + p.getName());
40. }
41. }
42. }
43.}
44.1.package com.msb.test10;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class CustomerThread extends Thread{//消费者线程
7. //共享商品：
8. private Product p;
9.
10. public CustomerThread(Product p) {
11. this.p = p;
12. }
13.
14. @Override
15. public void run() {
16. for (int i = 1; i <= 10 ; i++) {//i:消费次数
17. synchronized (p){
18. System.out.println("消费者消费了：" + p.getBrand() + "---" + p.getName());
19. }
20. }
21. }
22.}【2】利用同步方法解决问题：?
1.package com.msb.test11;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Product {//商品类
7. //品牌
8. private String brand;
9. //名字
10. private String name;
11. //setter,getter方法；
12.
13. public String getBrand() {
14. return brand;
15. }
16.
17. public void setBrand(String brand) {
18. this.brand = brand;
19. }
20.
21. public String getName() {
22. return name;
23. }
24.
25. public void setName(String name) {
26. this.name = name;
27. }
28.
29. //生产商品
30. public synchronized void setProduct(String brand,String name){
31. this.setBrand(brand);
32. try {
33. Thread.sleep(100);
34. } catch (InterruptedException e) {
35. e.printStackTrace();
36. }
37. this.setName(name);
38.
39.
40. //将生产信息做一个打印：
41. System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
42. }
43.
44. //消费商品：
45. public synchronized void getProduct(){
46. System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
47. }
48.}
49.1.package com.msb.test11;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class CustomerThread extends Thread{//消费者线程
7. //共享商品：
8. private Product p;
9.
10. public CustomerThread(Product p) {
11. this.p = p;
12. }
13.
14. @Override
15. public void run() {
16. for (int i = 1; i <= 10 ; i++) {//i:消费次数
17. p.getProduct();;
18. }
19. }
20.}1.public class ProducerThread extends Thread{//生产者线程
2. //共享商品：
3. private Product p;
4.
5. public ProducerThread(Product p) {
6. this.p = p;
7. }
8.
9. @Override
10. public void run() {
11. for (int i = 1; i <= 10 ; i++) {//生产十个商品 i:生产的次数
12. if(i % 2 == 0){
13. p.setProduct("费列罗","巧克力");
14. }else{
15. p.setProduct("哈尔滨","啤酒");
16. }
17. }
18. }
19.}（这个else中的代码在分解3中 演示了错误）
分解3
【1】原理：
【2】代码：
1.package com.msb.test11;
2.
3./**
4. * @author : msb-zhaoss
5. */
6.public class Product {//商品类
7. //品牌
8. private String brand;
9. //名字
10. private String name;
11.
12. //引入一个灯：true:红色 false 绿色
13. boolean flag = false;//默认情况下没有商品 让生产者先生产 然后消费者再消费
14. //setter,getter方法；
15.
16. public String getBrand() {
17. return brand;
18. }
19.
20. public void setBrand(String brand) {
21. this.brand = brand;
22. }
23.
24. public String getName() {
25. return name;
26. }
27.
28. public void setName(String name) {
29. this.name = name;
30. }
31.
32. //生产商品
33. public synchronized void setProduct(String brand,String name){
34. if(flag == true){//灯是红色，证明有商品，生产者不生产，等着消费者消费
35. try {
36. wait();
37. } catch (InterruptedException e) {
38. e.printStackTrace();
39. }
40. }
41. //灯是绿色的，就生产：
42. this.setBrand(brand);
43. try {
44. Thread.sleep(100);
45. } catch (InterruptedException e) {
46. e.printStackTrace();
47. }
48. this.setName(name);
49. //将生产信息做一个打印：
50. System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
51.
52. //生产完以后，灯变色：变成红色：
53. flag = true;
54. //告诉消费者赶紧来消费：
55. notify();
56. }
57.
58. //消费商品：
59. public synchronized void getProduct(){
60. if(!flag){//flag == false没有商品，等待生产者生产：
61. try {
62. wait();
63. } catch (InterruptedException e) {
64. e.printStackTrace();
65. }
66. }
67.
68. //有商品，消费：
69. System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
70.
71. //消费完：灯变色：
72. flag = false;
73. //通知生产者生产：
74. notify();
75. }
76.}
77.【3】原理：
注意：wait方法和notify方法 ?是必须放在同步方法或者同步代码块中才生效的 （因为在同步的基础上进行线程的通信才是有效的）
注意：sleep和wait的区别：sleep进入阻塞状态没有释放锁，wait进入阻塞状态但是同时释放了锁
【4】线程生命周期完整图：
Loc锁情况下的线程通信
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?返回之前，该线程必须重新获取锁。
唤醒所有等待线程。
如果所有的线程都在等待此条件，则唤醒所有线程。在从 await?返回之前，每个线程都必须重新获取锁。? ??
更改代码：
1.package com.msb.test12;
2.
3.import java.util.concurrent.locks.Condition;
4.import java.util.concurrent.locks.Lock;
5.import java.util.concurrent.locks.ReentrantLock;
6.
7./**
8. * @author : msb-zhaoss
9. */
10.public class Product {//商品类
11. //品牌
12. private String brand;
13. //名字
14. private String name;
15.
16. //声明一个Lock锁：
17. Lock lock = new ReentrantLock();
18. //搞一个生产者的等待队列：
19. Condition produceCondition = lock.newCondition();
20. //搞一个消费者的等待队列：
21. Condition consumeCondition = lock.newCondition();
22. //引入一个灯：true:红色 false 绿色
23. boolean flag = false;//默认情况下没有商品 让生产者先生产 然后消费者再消费
24. //setter,getter方法；
25.
26. public String getBrand() {
27. return brand;
28. }
29.
30. public void setBrand(String brand) {
31. this.brand = brand;
32. }
33.
34. public String getName() {
35. return name;
36. }
37.
38. public void setName(String name) {
39. this.name = name;
40. }
41.
42. //生产商品
43. public void setProduct(String brand,String name){
44. lock.lock();
45. try{
46. if(flag == true){//灯是红色，证明有商品，生产者不生产，等着消费者消费
47. try {
48. //wait();
49. //生产者阻塞，生产者进入等待队列中
50. produceCondition.await();
51. } catch (InterruptedException e) {
52. e.printStackTrace();
53. }
54. }
55. //灯是绿色的，就生产：
56. this.setBrand(brand);
57. try {
58. Thread.sleep(100);
59. } catch (InterruptedException e) {
60. e.printStackTrace();
61. }
62. this.setName(name);
63. //将生产信息做一个打印：
64. System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());
65.
66. //生产完以后，灯变色：变成红色：
67. flag = true;
68. //告诉消费者赶紧来消费：
69. //notify();
70. consumeCondition.signal();
71. }finally {
72. lock.unlock();
73. }
74. }
75.
76. //消费商品：
77. public void getProduct(){
78. lock.lock();
79. try{
80. if(!flag){//flag == false没有商品，等待生产者生产：
81. try {
82. // wait();
83. //消费者等待，消费者线程进入等待队列：
84. consumeCondition.await();
85. } catch (InterruptedException e) {
86. e.printStackTrace();
87. }
88. }
89.
90. //有商品，消费：
91. System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());
92.
93. //消费完：灯变色：
94. flag = false;
95. //通知生产者生产：
96. //notify();
97. produceCondition.signal();
98. }finally {
99. lock.unlock();
100. }
101. }
102.}
103.
文章来源:https://blog.csdn.net/weixin_45503872/article/details/135158821
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！