多线程学习--线程通信

客官°小女子只卖身不卖艺 2024-02-19 14:35 164阅读 0赞

线程彼此通信会涉及到等待/通知，其最经典的案例就是“生产者/消费者模式”。原理都是基于wait/notify的。

  1. 一生产一消费：
  3. //消费者
  4. class Consumer {
  5.     private String lock;
  7.     public Consumer(String lock) {
  8.         super();
  9.         this.lock = lock;
  10.     }
  12.     public void getValue() {
  13.         try {
  14.             synchronized (lock) {
  15.                 if (ValueObject.value.equals("")) {
  16.                     lock.wait();
  17.                 }
  18.                 System.out.println("get的值是" + ValueObject.value);
  19.                 ValueObject.value = "";
  20.                 lock.notify();
  21.             }
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }
  27. //生产者
  28. class Producer {
  29.     private String lock;
  31.     public Producer(String lock) {
  32.         super();
  33.         this.lock = lock;
  34.     }
  36.     public void setValue() {
  37.         try {
  38.             synchronized (lock) {
  39.                 if (!ValueObject.value.equals("")) {
  40.                     lock.wait();
  41.                 }
  42.                 String value = System.currentTimeMillis() + "_" + System.nanoTime();
  43.                 System.out.println("set的值是" + value);
  44.                 ValueObject.value = value;
  45.                 lock.notify();
  46.             }
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         }
  50.     }
  51. }
  53. public class test {
  54.     public static void main(String[] args) {
  55.         String lock = new String("");
  56.         Producer producer = new Producer(lock);
  57.         Consumer consumer = new Consumer(lock);
  58.         new Thread(()->{
  59.             while (true) {
  60.                 producer.setValue();
  61.             }
  62.         },"生产者").start();
  63.         new Thread(()->{
  64.             while (true) {
  65.                 consumer.getValue();
  66.             }
  67.         },"消费者").start();
  68.     }
  69. }

结果：

  1. set的值是1544676746771_186857371485669
  2. get的值是1544676746771_186857371485669
  3. set的值是1544676746771_186857371495584
  4. get的值是1544676746771_186857371495584
  5. set的值是1544676746771_186857371515716
  6. get的值是1544676746771_186857371515716
  7. 。。。。。。。。。。。。。。。。。。。。。

假死：无法不保证唤醒的是非当前线程

  1. class ValueObject {
  2.     public static String value = "";
  3. }
  5. class Producer {
  6.     private String lock;
  8.     public Producer(String lock) {
  9.         super();
  10.         this.lock = lock;
  11.     }
  13.     public void setValue() {
  14.         try {
  15.             synchronized (lock) {
  16.                 while (!ValueObject.value.equals("")) {
  17.                     System.out.println("生产者 " + Thread.currentThread().getName() + " WAITING了★");
  18.                     lock.wait();
  19.                 }
  20.                 System.out.println("生产者 " + Thread.currentThread().getName() + " RUNNABLE了");
  21.                 String value = System.currentTimeMillis() + "_" + System.nanoTime();
  22.                 ValueObject.value = value;
  23.                 lock.notify();
  24.             }
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  29. }
  30. class Consumer {
  31.     private String lock;
  33.     public Consumer(String lock) {
  34.         super();
  35.         this.lock = lock;
  36.     }
  38.     public void getValue() {
  39.         try {
  40.             synchronized (lock) {
  41.                 while (ValueObject.value.equals("")) {
  42.                     System.out.println("消费者 " + Thread.currentThread().getName() + " WAITING了☆");
  43.                     lock.wait();
  44.                 }
  45.                 System.out.println("消费者 " + Thread.currentThread().getName() + " RUNNABLE了");
  46.                 ValueObject.value = "";
  47.                 lock.notify();
  48.             }
  49.         } catch (InterruptedException e) {
  50.             e.printStackTrace();
  51.         }
  52.     }
  53. }
  55. class ThreadP extends Thread {
  56.     private Producer p;
  58.     public ThreadP(Producer p) {
  59.         super();
  60.         this.p = p;
  61.     }
  63.     @Override
  64.     public void run() {
  65.         while (true) {
  66.             p.setValue();
  67.         }
  68.     }
  69. }
  70. class ThreadC extends Thread {
  71.     private Consumer consumer;
  73.     public ThreadC(Consumer consumer) {
  74.         super();
  75.         this.consumer = consumer;
  76.     }
  78.     @Override
  79.     public void run() {
  80.         while (true) {
  81.             consumer.getValue();
  82.         }
  83.     }
  84. }
  85. public class Run8_allWait {
  86.     public static void main(String[] args) throws InterruptedException {
  87.         String lock = new String("");
  88.         Producer producer = new Producer(lock);
  89.         Consumer consumer = new Consumer(lock);
  90.         ThreadP[] pThread = new ThreadP[2];
  91.         ThreadC[] cThread = new ThreadC[2];
  92.         for (int i = 0; i < 2; i++) {
  93.             pThread[i] = new ThreadP(producer);
  94.             pThread[i].setName("生产者" + (i + 1));
  95.             cThread[i] = new ThreadC(consumer);
  96.             cThread[i].setName("消费者" + (i + 1));
  97.             pThread[i].start();
  98.             cThread[i].start();
  99.         }
  100.         Thread.sleep(5000);
  101.         //获取当前活动的线程
  102.         Thread[] threads = new Thread[Thread.currentThread().getThreadGroup().activeCount()];
  103.         Thread.currentThread().getThreadGroup().enumerate(threads);
  104.         for (int i = 0; i < threads.length; i++) {
  105.             System.out.println(threads[i].getName() + " " + threads[i].getState());
  106.         }
  108.     }
  109. }

结果：

  1. 生产者 生产者1 RUNNABLE了
  2. 生产者 生产者1 WAITING了★
  3. 生产者 生产者2 WAITING了★
  4. 消费者 消费者1 RUNNABLE了
  5. 消费者 消费者1 WAITING了☆
  6. 生产者 生产者1 RUNNABLE了
  7. 生产者 生产者1 WAITING了★
  8. 生产者 生产者2 WAITING了★
  9. 消费者 消费者2 RUNNABLE了
  10. 消费者 消费者2 WAITING了☆
  11. 消费者 消费者1 WAITING了☆
  12. main RUNNABLE
  13. Monitor Ctrl-Break RUNNABLE
  14. 生产者1 WAITING
  15. 消费者1 WAITING
  16. 生产者2 WAITING
  17. 消费者2 WAITING

分析：jps/jstack pid 分析线程问题 jdk自带工具

jsp:

2018121313265596.png

jstack 7444:

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1

线程根据等待和唤醒进行通信成功，但是无法不保证唤醒的是非当前线程，比如“生产者”唤醒 “生产者” / “消费者” 唤醒 “消费者”，从而导致了程序最后呈“假死状态”。

解决方法:notify()换成notifyAll().

  1. 一生产与多消费：
  3. class MyStack {
  4.     private List list = new ArrayList();
  6.     synchronized public void push() {
  7.         try {
  8.             if (list.size() == 1) {
  9.                 System.out.println("push操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  10.                 this.wait();
  11.             }
  12.             list.add(Math.random());
  13.             this.notify();
  14.             System.out.println("push = " + list.size());
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  20.     synchronized public String pop() {
  21.         String returnValue = "";
  22.         try {
  23.             if (list.size() == 0) {
  24.                 System.out.println("pop操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  25.                 this.wait();
  26.             }
  27.             returnValue = list.get(0) + "  " + Thread.currentThread().getName();
  28.             list.remove(0);
  29.             this.notify();
  30.             System.out.println("pop = " + list.size() + "  Mystack的pop方法中 线程" + Thread.currentThread().getName());
  31.         } catch (InterruptedException e) {
  32.             e.printStackTrace();
  33.         }
  34.         return returnValue;
  35.     }
  36. }
  37. class Producer {
  38.     private MyStack myStack;
  40.     public Producer(MyStack myStack) {
  41.         super();
  42.         this.myStack = myStack;
  43.     }
  45.     public void pushService() {
  46.         myStack.push();
  47.     }
  49. }
  50. class Consumer {
  51.     private MyStack myStack;
  53.     public Consumer(MyStack myStack) {
  54.         super();
  55.         this.myStack = myStack;
  56.     }
  58.     public void popService() {
  59.         System.out.println("pop = " + myStack.pop() + "  Consumer的popService方法中打印pop返回值");
  60.     }
  62. }
  63. class P_Thread extends Thread {
  64.     private Producer p;
  66.     public P_Thread(Producer p) {
  67.         super();
  68.         this.p = p;
  69.     }
  71.     @Override
  72.     public void run() {
  73.         while (true) {
  74.             p.pushService();
  75.         }
  76.     }
  77. }
  78. class C_Thread extends Thread {
  79.     private Consumer c;
  81.     public C_Thread(Consumer c) {
  82.         super();
  83.         this.c = c;
  84.     }
  86.     @Override
  87.     public void run() {
  88.         while (true) {
  89.             c.popService();
  90.         }
  91.     }
  92. }
  93. public class Run9_oneP_manyC {
  94.     public static void main(String[] args) {
  95.         MyStack myStack = new MyStack();
  96.         Producer p = new Producer(myStack);
  97.         Consumer c1 = new Consumer(myStack);
  98.         Consumer c2 = new Consumer(myStack);
  99.         Consumer c3 = new Consumer(myStack);
  100.         Consumer c4 = new Consumer(myStack);
  101.         Consumer c5 = new Consumer(myStack);
  103.         P_Thread p_thread = new P_Thread(p);
  104.         p_thread.start();
  105.         C_Thread c_thread1 = new C_Thread(c1);
  106.         C_Thread c_thread2 = new C_Thread(c2);
  107.         C_Thread c_thread3 = new C_Thread(c3);
  108.         C_Thread c_thread4 = new C_Thread(c4);
  109.         C_Thread c_thread5 = new C_Thread(c5);
  110.         c_thread1.start();
  111.         c_thread2.start();
  112.         c_thread3.start();
  113.         c_thread4.start();
  114.         c_thread5.start();
  116.     }
  117. }

结果：

  1. "C:\Program Files\Java\jdk1.8.0_181\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.4\lib\idea_rt.jar=51167:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.4\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;C:\Users\zhw\IdeaProjects\java-learning\java-multithread\target\classes" com.brianway.learning.java.multithread.communication.example9.Run9_oneP_manyC
  2. Exception in thread "Thread-1" Exception in thread "Thread-2" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
  3. push = 1
  4.     at java.util.ArrayList.rangeCheck(ArrayList.java:657)
  5. push操作中的： Thread-0 线程呈wait状态
  6. pop = 0  Mystack的pop方法中 线程Thread-3
  7.     at java.util.ArrayList.get(ArrayList.java:433)
  8. pop = 0.859192167402362  Thread-3  Consumer的popService方法中打印pop返回值
  9. pop操作中的： Thread-2 线程呈wait状态
  10. pop操作中的： Thread-1 线程呈wait状态
  11.     at com.brianway.learning.java.multithread.communication.example9.MyStack.pop(Run9_oneP_manyC.java:41)
  12. pop操作中的： Thread-3 线程呈wait状态
  13. push = 1
  14.     at com.brianway.learning.java.multithread.communication.example9.Consumer.popService(Run9_oneP_manyC.java:73)
  15. push操作中的： Thread-0 线程呈wait状态
  16. pop = 0  Mystack的pop方法中 线程Thread-5
  17.     at com.brianway.learning.java.multithread.communication.example9.C_Thread.run(C_Thread.java:17)
  18. pop = 0.381657285316201  Thread-5  Consumer的popService方法中打印pop返回值
  19. pop操作中的： Thread-4 线程呈wait状态
  20. java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
  21. pop操作中的： Thread-5 线程呈wait状态
  22.     at java.util.ArrayList.rangeCheck(ArrayList.java:657)
  23.     at java.util.ArrayList.get(ArrayList.java:433)
  24.     at com.brianway.learning.java.multithread.communication.example9.MyStack.pop(Run9_oneP_manyC.java:41)
  25.     at com.brianway.learning.java.multithread.communication.example9.Consumer.popService(Run9_oneP_manyC.java:73)
  26.     at com.brianway.learning.java.multithread.communication.example9.C_Thread.run(C_Thread.java:17)

原因：

  1. if判断存在弊端，条件发生改变时没有得到及时的响应，多个呈wait状态的线程被唤醒，继而执行list.remove(0)出现异常java.lang.IndexOutOfBoundsException.
  3. 解决办法：

if 改为while, while判断解决条件发生改变时没有得到及时的响应，多个呈wait状态的线程被唤醒的问题，但会出现新的问题：假死，同时需要将notify()换成notifyAll()

  1. class MyStack {
  2.     private List list = new ArrayList();
  4.     synchronized public void push() {
  5.         try {
  6.             while (list.size() == 1) {
  7.                 System.out.println("push操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  8.                 this.wait();
  9.             }
  10.             list.add(Math.random());
  11.             this.notifyAll();
  12.             System.out.println("push = " + list.size());
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  18.     synchronized public String pop() {
  19.         String returnValue = "";
  20.         try {
  21.             while (list.size() == 0) {
  22.                 System.out.println("pop操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  23.                 this.wait();
  24.             }
  25.             returnValue = list.get(0) + "  " + Thread.currentThread().getName();
  26.             list.remove(0);
  27.             this.notifyAll();
  28.             System.out.println("pop = " + list.size() + "  Mystack的pop方法中 线程" + Thread.currentThread().getName());
  29.         } catch (InterruptedException e) {
  30.             e.printStackTrace();
  31.         }
  32.         return returnValue;
  33.     }
  34. }
  36. 多生产与一消费:notifyAll()代替notify()，将一直运行下去
  38. class MyStack {
  39.     private List list = new ArrayList();
  41.     synchronized public void push() {
  42.         try {
  43.             while (list.size() == 1) {
  44.                 System.out.println("push操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  45.                 this.wait();
  46.             }
  47.             list.add(Math.random());
  48.             this.notifyAll();
  49.             System.out.println("push = " + list.size());
  50.         } catch (InterruptedException e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  55.     synchronized public String pop() {
  56.         String returnValue = "";
  57.         try {
  58.             while (list.size() == 0) {
  59.                 System.out.println("pop操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  60.                 this.wait();
  61.             }
  62.             returnValue = list.get(0) + "  " + Thread.currentThread().getName();
  63.             list.remove(0);
  64.             this.notifyAll();
  65.             System.out.println("pop = " + list.size() + "  Mystack的pop方法中 线程" + Thread.currentThread().getName());
  66.         } catch (InterruptedException e) {
  67.             e.printStackTrace();
  68.         }
  69.         return returnValue;
  70.     }
  71. }
  72. class Producer {
  73.     private MyStack myStack;
  75.     public Producer(MyStack myStack) {
  76.         super();
  77.         this.myStack = myStack;
  78.     }
  80.     public void pushService() {
  81.         myStack.push();
  82.     }
  84. }
  85. class Consumer {
  86.     private MyStack myStack;
  88.     public Consumer(MyStack myStack) {
  89.         super();
  90.         this.myStack = myStack;
  91.     }
  93.     public void popService() {
  94.         System.out.println("pop = " + myStack.pop() + "  Consumer的popService方法中打印pop返回值");
  95.     }
  97. }
  98. class C_Thread extends Thread {
  99.     private Consumer c;
  101.     public C_Thread(Consumer c) {
  102.         super();
  103.         this.c = c;
  104.     }
  106.     @Override
  107.     public void run() {
  108.         while (true) {
  109.             c.popService();
  110.         }
  111.     }
  112. }
  113. class P_Thread extends Thread {
  114.     private Producer p;
  116.     public P_Thread(Producer p) {
  117.         super();
  118.         this.p = p;
  119.     }
  121.     @Override
  122.     public void run() {
  123.         while (true) {
  124.             p.pushService();
  125.         }
  126.     }
  127. }
  129. public class test{
  130.     public static void main(String[] args) {
  131.         MyStack myStack = new MyStack();
  133.         int pNum = 6;
  134.         Producer[] producers = new Producer[pNum];
  135.         P_Thread[] p_threads = new P_Thread[pNum];
  137.         for (int i = 0; i < pNum; i++) {
  138.             producers[i] = new Producer(myStack);
  139.         }
  141.         for (int i = 0; i < pNum; i++) {
  142.             p_threads[i] = new P_Thread(producers[i]);
  143.             p_threads[i].start();
  144.         }
  146.         Consumer c = new Consumer(myStack);
  147.         C_Thread c_thread = new C_Thread(c);
  148.         c_thread.start();
  150.     }
  151. }

多生产与多消费: 一直运行下去

  1. class MyStack {
  2.     private List list = new ArrayList();
  4.     synchronized public void push() {
  5.         try {
  6.             while (list.size() == 1) {
  7.                 System.out.println("push操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  8.                 this.wait();
  9.             }
  10.             list.add(Math.random());
  11.             this.notifyAll();
  12.             System.out.println("push = " + list.size());
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  18.     synchronized public String pop() {
  19.         String returnValue = "";
  20.         try {
  21.             while (list.size() == 0) {
  22.                 System.out.println("pop操作中的： " + Thread.currentThread().getName() + " 线程呈wait状态");
  23.                 this.wait();
  24.             }
  25.             returnValue = list.get(0) + "  " + Thread.currentThread().getName();
  26.             list.remove(0);
  27.             this.notifyAll();
  28.             System.out.println("pop = " + list.size() + "  Mystack的pop方法中 线程" + Thread.currentThread().getName());
  29.         } catch (InterruptedException e) {
  30.             e.printStackTrace();
  31.         }
  32.         return returnValue;
  33.     }
  34. }
  35. class Producer {
  36.     private MyStack myStack;
  38.     public Producer(MyStack myStack) {
  39.         super();
  40.         this.myStack = myStack;
  41.     }
  43.     public void pushService() {
  44.         myStack.push();
  45.     }
  47. }
  48. class Consumer {
  49.     private MyStack myStack;
  51.     public Consumer(MyStack myStack) {
  52.         super();
  53.         this.myStack = myStack;
  54.     }
  56.     public void popService() {
  57.         System.out.println("pop = " + myStack.pop() + "  Consumer的popService方法中打印pop返回值");
  58.     }
  60. }
  61. class C_Thread extends Thread {
  62.     private Consumer c;
  64.     public C_Thread(Consumer c) {
  65.         super();
  66.         this.c = c;
  67.     }
  69.     @Override
  70.     public void run() {
  71.         while (true) {
  72.             c.popService();
  73.         }
  74.     }
  75. }
  76. class P_Thread extends Thread {
  77.     private Producer p;
  79.     public P_Thread(Producer p) {
  80.         super();
  81.         this.p = p;
  82.     }
  84.     @Override
  85.     public void run() {
  86.         while (true) {
  87.             p.pushService();
  88.         }
  89.     }
  90. }
  92. public class test{
  93.     public static void main(String[] args) {
  94.         MyStack myStack = new MyStack();
  96.         int pNum = 6;
  97.         Producer[] producers = new Producer[pNum];
  98.         P_Thread[] p_threads = new P_Thread[pNum];
  100.         for (int i = 0; i < pNum; i++) {
  101.             producers[i] = new Producer(myStack);
  102.         }
  104.         for (int i = 0; i < pNum; i++) {
  105.             p_threads[i] = new P_Thread(producers[i]);
  106.             p_threads[i].start();
  107.         }
  109.         int cNum = 8;
  110.         Consumer[] consumers = new Consumer[cNum];
  111.         C_Thread[] c_threads = new C_Thread[cNum];
  113.         for (int i = 0; i < cNum; i++) {
  114.             consumers[i] = new Consumer(myStack);
  115.         }
  117.         for (int i = 0; i < cNum; i++) {
  118.             c_threads[i] = new C_Thread(consumers[i]);
  119.             c_threads[i].start();
  120.         }
  122.     }
  123. }

发表评论

表情：
评论列表 （有 0 条评论，164人围观）

还没有评论，来说两句吧...

相关阅读

    相关 多线程12/线程通信

    线程通信的例子:使用两个线程打印1-100。线程1，线程2交替打印 前置知识： 1. wait(); 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

    电玩女神电玩女神/ 0 赞/ 99 阅读

    相关 Java 多线程-多线程通信

    最近，美美非常的爱吃栗子，剥栗子却有些麻烦，这个任务理所当然的交给了帅帅，每一次，帅帅都会把热气腾腾的栗子剥好，然后放进一个盘子里，而美美每次都会从盘子里拿一个栗子吃： !

    一时失言乱红尘一时失言乱红尘/ 0 赞/ 361 阅读

    相关 多线程（3）- 线程通信

    线程之间的通信： 多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。 等待唤醒机...

    红太狼红太狼/ 0 赞/ 830 阅读