java多线程学习03（文章留有悬念，等待日后复盘）

转x33g5p2x  于2021-11-25 转载在 Java  
字(11.6k)|赞(0)|评价(0)|浏览(826)

首先说一下自己做这个创建四个进程的一个小问题：

题目要求说的是：需要你创建四个进程，两个进程为.wait两个进程为.notify,然后我仿照创建了以后是这样子的:

  1. package 任务十__多线程;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-22 21:20 */
  4. public class Test1 {
  5.     public static void main(String[] args) {
  6.         Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 synchronized ("锁1") {
  10.                     System.out.println("t1 start");
  11.                     try {
  12.    // t1 释放锁
  13.                         "锁1".wait();
  14.                     } catch (Exception e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                     System.out.println("t1 end");
  18.                 }
  19.             }
  20.         });
  21.         Thread t2 = new Thread(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 synchronized ("锁2") {
  25.                     System.out.println("t2 start");
  26.                     try {
  27.                  // 通知 t1 进入等待队列
  29.                         "锁2".wait();
  30.                     } catch (Exception e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                     System.out.println("t2 end");
  34.                 }
  35.             }
  36.         });
  38.         Thread t3 = new Thread(new Runnable() {
  39.             @Override
  40.             public void run() {
  41.                 synchronized ("锁3") {
  42.                     System.out.println("t3 start");
  43.                     try {
  44.                         // 通知 t3 进入等待队列
  46.                         "锁3".notify();
  47.                     } catch (Exception e) {
  48.                         e.printStackTrace();
  49.                     }
  50.                     System.out.println("t3 end");
  51.                 }
  52.             }
  53.         });
  55.         Thread t4 = new Thread(new Runnable() {
  56.             @Override
  57.             public void run() {
  58.                 synchronized ("锁4") {
  59.                     System.out.println("t4 start");
  60.                     try {
  61.                         // 通知 t3 进入等待队列
  63.                         "锁4".notify();
  64.                     } catch (Exception e) {
  65.                         e.printStackTrace();
  66.                     }
  67.                     System.out.println("t4 end");
  68.                 }
  69.             }
  70.         });
  72.         t1.start();
  73.         t2.start();
  74.         t3.start();
  75.         t4.start();
  76.     }
  78. }

输出结果是这样：

我们可以看到为什么t1和t2没有返回值呢？

我开始好奇，感觉因该是

这个地方出了问题，后来通过询问同学得知：锁是需要钥匙和它对应的，对于一个锁在被wait以后，他需要一个notify来去“救”原来这个wait，而这个notify必须是前面.wait的notify，也就是我们在synchronized上锁以后，会给他传入一个名字：“锁1”,这样的一个字符串，

倘若后面是.wait，那么后续线程中必须有一个同样的synchronized（“锁1”）然后去执行.notify,否则将无法释放锁1的结束语句。

举一个例子，我写了六个进程分别对应锁123451*，前两个是.wait，后四个是.notify,然后按照原理就是，notify的代码不需要“钥匙”去解他所以可以直接输出开始和结束，线程1和2只有1有“钥匙”：也就是第六个线程的.notify,第二个线程的.wait将永远无法输出他的结束：

由图可知确实是这样，1345都有开始结束，只有2不可以结束！

然后我们回归正题去写这个题：（就是让每一个.wait锁都有自己的钥匙）

  1. package 任务十__多线程;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-22 21:20 */
  4. public class Test1 {
  5.     public static void main(String[] args) {
  6.         Thread t1 = new Thread(new Runnable() {
  7.             @Override
  8.             public void run() {
  9.                 synchronized ("锁1") {
  10.                     System.out.println("t1 start");
  11.                     try {
  12.    // t1 释放锁
  13.                         "锁1".wait();
  14.                     } catch (Exception e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                     System.out.println("t1 end");
  18.                 }
  19.             }
  20.         });
  21.         Thread t2 = new Thread(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 synchronized ("锁2") {
  25.                     System.out.println("t2 start");
  26.                     try {
  27.                  // 通知 t1 进入等待队列
  29.                         "锁2".wait();
  30.                     } catch (Exception e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                     System.out.println("t2 end");
  34.                 }
  35.             }
  36.         });
  38.         Thread t3 = new Thread(new Runnable() {
  39.             @Override
  40.             public void run() {
  41.                 synchronized ("锁1") {
  42.                     System.out.println("t3 start");
  43.                     try {
  44.                         // 通知 t3 进入等待队列
  46.                         "锁1".notify();
  47.                     } catch (Exception e) {
  48.                         e.printStackTrace();
  49.                     }
  50.                     System.out.println("t3 end");
  51.                 }
  52.             }
  53.         });
  55.         Thread t4 = new Thread(new Runnable() {
  56.             @Override
  57.             public void run() {
  58.                 synchronized ("锁2") {
  59.                     System.out.println("t4 start");
  60.                     try {
  61.                         // 通知 t3 进入等待队列
  63.                         "锁2".notify();
  64.                     } catch (Exception e) {
  65.                         e.printStackTrace();
  66.                     }
  67.                     System.out.println("t4 end");
  68.                 }
  69.             }
  70.         });
  73.         t1.start();
  74.         t2.start();
  75.         t3.start();
  76.         t4.start();
  78.     }
  80. }

结果：第一次：

第二次：

我们可以由此得知线程的启动并不是根据start的顺序来决定的！

柜台卖票：（Therad实现）

  1. package 任务十__多线程;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-24 16:44 */
  4. public class Tick {
  6.     public static void main(String[] args) {
  7.         Window w1 = new Window("柜台一");
  8.         Window w2 = new Window("柜台二");
  9.         Window w3 = new Window("柜台三");
  11.         w1.start();
  12.         w2.start();
  13.         w3.start();
  15.     }
  17. }
  18. class Window extends Thread{
  19.     private static int  number = 100;
  21.     public Window(String name){
  22.         super(name);
  23.     }
  25.     @Override
  26.     public void run() {
  27.        while (number>0){
  28.            number--;
  29.            System.out.println(getName()+"兑换成功一张票"+"票号为："+number);
  30.        }
  31.     }
  32. }

输出结果：

这里有一个小问题就是：一开始的99和98票消失了！

解决方法：为每一个票添加标记，可以通过放到一个数组里面然后去验证一下是否在数组里面

柜台买票：（ Runnable 接口实现）：

首先说一下自己一开始的想法那就是：存放到集合里面去三个线程遍历一个循环

  1. package 任务十__多线程.售票;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. /** * @author ${范涛之} * @Description * @create 2021-11-24 20:25 */
  8. public class Tick1 {
  10.     public static void main(String[] args) {
  11.         List list = new ArrayList();
  12.         for (int i = 1; i <= 100; i++){
  13.             list.add(i);
  14.         }
  15.         Iterator iterator = list.iterator();
  16.         Thread t1 = new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                     while (iterator.hasNext()) {
  20.                         for (int i = 0; i < list.size(); i++) {
  21.                             synchronized ("lock") {
  22.                                 String threadname = Thread.currentThread().getName();
  23.                                 System.out.println(threadname + "柜台正在兑换" + list.get(i) + "台iPhone");
  24.                                 list.remove(i); // 删除已经遍历的元素
  25.                             }
  26.                         }
  27.                     }
  28.             }
  29.         });
  30.         Thread t2 = new Thread(new Runnable() {
  31.             @Override
  32.             public void run() {
  33.                     while (iterator.hasNext()) {
  34.                         for (int i = 0; i < list.size(); i++) {
  35.                             synchronized ("lock") {
  36.                                 String threadname = Thread.currentThread().getName();
  37.                                 System.out.println(threadname + "柜台正在兑换" + list.get(i) + "台iPhone");
  38.                                 list.remove(i);
  39.                             }
  40.                         }
  41.                     }
  42.                 }
  43.         });
  44.         Thread t3 = new Thread(new Runnable() {
  45.             @Override
  46.             public void run() {
  47.                     while (iterator.hasNext()) {
  49.                         for (int i = 0; i < list.size(); i++) {
  50.                             synchronized ("lock") {
  51.                                 String threadname = Thread.currentThread().getName();
  52.                                 System.out.println(threadname + "柜台正在兑换" + list.get(i) + "台iPhone");
  53.                                 list.remove(i);
  54.                             }
  55.                         }
  56.                     }
  57.             }
  58.         });
  60.         t1.start();
  61.         t2.start();
  62.         t3.start();
  64.     }
  65. }

上面这段代码由于自己还没有学习，java委托和事件，所以并没有全部完成，以后我会反过来解决这个题，如何三个线程干同一件事情

然后接下来讲解一下怎样使用Runnable 简单实现买票：

  1. package 任务十__多线程.售票;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-24 21:43 */
  4. public class Ticket implements  Runnable {
  5.     private   int  num1 = 0;    //出票数
  6.     private   int  num2 = 100;   //剩余票数
  7.     @Override
  8.     public void run() {
  9.         while (true) {
  10.             synchronized (this) {
  11.                 if (num2 <= 0) {
  12.                     break;
  13.                 }
  14.                 num1++;
  15.                 num2--;
  16.                 System.out.println("显示出票信息" + Thread.currentThread().getName() + "抢到第" + num1 + "张票，剩余" + num2 + "张票");
  17.             }
  18.         }
  19.     }
  20.     static class Test {
  21.         public static void main(String[] args) {
  22.             Ticket ticket = new Ticket();
  23.             Thread g1 = new Thread(ticket,"柜台一");
  24.             Thread g2 = new Thread(ticket,"柜台二");
  25.             Thread g3 = new Thread(ticket,"柜台三");
  26.             g1.start();
  27.             g2.start();
  28.             g3.start();
  29.         }
  30.     }
  31. }

这里遇到了一个小问题：就是总是先启动的哪个线程先抢票而且很有可能他会一直抢下去

这里说一个改进方法：

  1. package 任务十__多线程.售票;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-24 23:43 */
  4. class SaleThread implements Runnable {
  6.     /** * 使用静态成员变量作为100张票的保存变量，是一个共享资源。 */
  7.     private static int tickets = 20;
  9.     @Override
  10.     public void run() {
  12.         // 完成售票过程
  13.         while (true) {
  14.    /* 字符串可以作为锁对象，因为双引号包含的字符串不管在代码中如何运行，有且只有一个 */
  15.             synchronized (Thread.currentThread().getName()) {
  17.                 try {
  18.                     Thread.sleep(100);
  19.                 } catch (InterruptedException e) {
  20.                     e.printStackTrace();
  21.                 }
  23.                 if (tickets > 0) {
  24.                     System.out.println(Thread.currentThread().getName() + "售出了" + tickets + "张票");
  25.                     tickets--;
  26.                 } else {
  27.                     System.out.println(Thread.currentThread().getName() + "售罄！！！");
  28.                     break;
  29.                 }
  30.             }
  31.         }
  32.     }
  33. }
  35. public class Demo {
  36.     public static void main(String[] args) {
  37.         Thread t1 = new Thread(new SaleThread(), "售票人员1");
  38.         Thread t2 = new Thread(new SaleThread(), "售票人员2");
  39.         Thread t3 = new Thread(new SaleThread(), "售票人员3");
  41.         t1.start();
  42.         t2.start();
  43.         t3.start();
  44.     }
  45. }

运行结果：

说一下改进在了什么地方： synchronized (Thread.currentThread().getName()) {}

我们之前都是用的synchronized{}，但是这样写会导致synchronized (this) 会连续执行当前线程，所以会出现大片大片一样的代码

使用Thread实现：

  1. package 任务十__多线程.售票;
  3. /** * @author ${范涛之} * @Description * @create 2021-11-24 23:41 */
  4. public class Ticket2 extends Thread {
  5.         private  int num1 = 0;
  6.         private  int num2 = 100;
  7.     @Override
  8.     public void run() {
  9.         while (true) {
  10.             synchronized (Thread.currentThread().getName()){ ;
  11.             if (num2 <= 0) {
  12.                 break;
  13.             }
  14.             num1++;
  15.             num2--;
  16.             System.out.println("显示出票信息" + Thread.currentThread().getName() + "抢到第" + num1 + "张票，剩余" + num2 + "张票");
  17.         }
  18.         }
  19.     }
  20. }
  21. class  Function{
  22.     public static void main(String[] args) {
  23.         Ticket2 ticket2 = new Ticket2();
  24.         Thread t1 = new Thread(ticket2,"柜台一");
  25.         Thread t2 = new Thread(ticket2,"柜台二");
  26.         Thread t3 = new Thread(ticket2,"柜台三");
  27.         t1.start();
  28.         t2.start();
  29.         t3.start();
  30.     }
  31. }

总是遇到线程安全性的问题：就是同一个票同时被不同线程拿到的假象，这里写一个真实有效的代码：

  1. package 任务十__多线程.售票;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class TestDemo {
  8.     //定义售票线程类（也就是窗口）
  9.     public static class Station extends Thread{
  10.         //构造方法给线程名字赋值
  11.         public Station(String name) {
  12.             super(name);
  13.         }
  14.         //票数要静态定义
  15.         static int tick=50;
  16.         //静态钥匙
  17.         static Object ob ="key"; //值是任意的
  18.         //重写run方法，实现售票操作
  19.         @Override
  20.         public void run() {
  21.             List<Integer>  list = new ArrayList<>();
  22.             while (tick>0) {
  23.                 synchronized("key") { //必须使用一个同步锁，进去的人会把钥匙拿在手上，出来后才能交出钥匙
  24.                     if (tick>0) {
  25.                         System.out.printf("%s卖出了第%d张票 \n",getName(),tick);
  26.                         list.add(tick);
  27.                         tick--;
  28.                     }else {
  29.                         System.out.printf("%s：票已售空 \n",getName());
  31.                     }
  32.                 }
  33.                 try {
  34.                     sleep((int)(Math.random()*3000)+1); //随机休息1-3000ms
  35.                 }catch (InterruptedException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.             System.out.printf("%s 销售情况： %s \n",getName(),list.toString());
  40.         }
  41.     }
  43.     public static void main(String[] args) {
  44.         //实例化站台对象，并为每一个站台取名字(8个线程窗口一起卖5张票）
  45.         for (int i=1; i<=8; i++) {
  46.             String sName="窗口" + String.valueOf(i);
  47.             Station  Station = new Station(sName);
  48.             Station.start();
  49.         }
  51.     }
  53. }

可以看出这里就很正常，现在太晚了脑子有点糊，改日回过神来再看！先就到这里了

这里再说一下吧，关于synchronized（this）这个真的令人可苦恼的东西，他并不是说会造成真正的线程安全问题，他仅仅是显示上的问题比如：

  1. package 任务十__多线程.售票;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class TestDemo {
  8.     //定义售票线程类（也就是窗口）
  9.     public static class Station extends Thread{
  10.         //构造方法给线程名字赋值
  11.         public Station(String name) {
  12.             super(name);
  13.         }
  14.         //票数要静态定义
  15.         static int tick=50;
  16.         //静态钥匙
  17.         static Object ob ="key"; //值是任意的
  18.         //重写run方法，实现售票操作
  19.         @Override
  20.         public void run() {
  21.             List<Integer>  list = new ArrayList<>();
  22.             while (tick>0) {
  23.                 synchronized(this) { //必须使用一个同步锁，进去的人会把钥匙拿在手上，出来后才能交出钥匙
  24.                     if (tick>0) {
  25.                         System.out.printf("%s卖出了第%d张票 \n",getName(),tick);
  26.                         list.add(tick);
  27.                         tick--;
  28.                     }else {
  29.                         System.out.printf("%s：票已售空 \n",getName());
  31.                     }
  32.                 }
  33.                 try {
  34.                     sleep((int)(Math.random()*3000)+1); //随机休息1-3000ms
  35.                 }catch (InterruptedException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.             System.out.printf("%s 销售情况： %s \n",getName(),list.toString());
  40.         }
  41.     }
  43.     public static void main(String[] args) {
  44.         //实例化站台对象，并为每一个站台取名字(8个线程窗口一起卖5张票）
  45.         for (int i=1; i<=8; i++) {
  46.             String sName="窗口" + String.valueOf(i);
  47.             Station  Station = new Station(sName);
  48.             Station.start();
  49.         }
  51.     }
  53. }

运行结果：

我们可以看出来其实真正的数据并没有错误！！！！！

这里留下悬念，等待日后的复盘！！

分割线···································································································

线程池：使用 newScheduledThreadPool 线程池实现每隔 1 分钟打印一条消息

首先讲解一下使用 newScheduledThreadPool 是怎样使用的以及一些参数说明：

参数说明：

  • command：执行线程
  • initialDelay：初始化延时
  • period：两次开始执行最小间隔时间
  • unit：计时单位

1：首先说一下它的特点：延时启动 、定时启动 、可以自定义最大线程池数量

2：创建实例：

  1. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

这里如果没有特殊需求要指定最大线程池数量的话，建议最大线程池数量=运行程序机器的cpu核心数，即

  1. int cpuNubmer = Runtime.getRuntime().availableProcessors();
  2. ScheduledExecutorService executorService = Executors.newScheduledThreadPool(cpuNubmer);

3：延时运行举例：这里需要用匿名内部类的方式，实现Runnable接口，重写Runnable的run方法，将Runnable类型的参数传入schedule方法中。

  1. final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
  2. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
  3. System.out.println("提交时间: " + sdf.format(new Date()));
  4. scheduledThreadPool.schedule(new Runnable() {
  5.     @Override
  6.     public void run() {
  7.         System.out.println("运行时间: " + sdf.format(new Date()));
  8.     }
  9. }, 3, TimeUnit.SECONDS);//延迟3秒执行
  10. scheduledThreadPool.shutdown();

4：用lambda表达式的写法：函数式编程：

  1. final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
  2. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
  3. System.out.println("提交时间: " + sdf.format(new Date()));
  4. scheduledThreadPool.schedule(() -> System.out.println("运行时间: " + sdf.format(new Date())), 3, TimeUnit.SECONDS);
  5. scheduledThreadPool.shutdown();

每分钟输出与每秒钟输出：

  1. package 任务十__多线程.周期线程池;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.ScheduledExecutorService;
  5. import java.util.concurrent.TimeUnit;
  7. /** * @author ${范涛之} * @Description * @create 2021-11-25 0:49 */
  8. public class Test {
  10.     public static void main(String[] args) {
  11.         ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
  12.         pool.scheduleAtFixedRate(new Runnable() {
  13.             @Override
  14.             public void run() {
  15.                 System.out.println("一分钟过去了");
  16.             }
  17.         }, 3, 1, TimeUnit.MINUTES);
  18.     }
  20. }
  25. 改成秒：
  26. package 任务十__多线程.周期线程池;
  28. import java.util.concurrent.Executors;
  29. import java.util.concurrent.ScheduledExecutorService;
  30. import java.util.concurrent.TimeUnit;
  32. /** * @author ${范涛之} * @Description * @create 2021-11-25 0:49 */
  33. public class Test {
  35.     public static void main(String[] args) {
  36.         ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
  37.         pool.scheduleAtFixedRate(new Runnable() {
  38.             @Override
  39.             public void run() {
  40.                 System.out.println("一分钟过去了");
  41.             }
  42.         }, 3, 1, TimeUnit.SECONDS);
  43.     }
  45. }

其实就是最后的TimeUnit修改一下就好，根据我上面说的参数自己定义即可！

多线程正式完结！

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/justleavel/article/details/121520228

内容来源于网络，如有侵权，请联系作者删除！

mysqlDatabase数据库java学习

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com