线程通信实现方式

ゞ 浴缸里的玫瑰 2022-04-08 12:39 314阅读 0赞

第一种方式是wait和(notify)notifyAll的方式，一个线程负责变量的新增，一个线程负责变量的相减，一个线程操作完，另一个线程等待，具体操作请看下面的代码

这里需要注意的是一定尽量要用while判断，不要用if判断

第一消除notifyAll() 引起的并发问题，第二在while循环里而不是if语句下使用wait。这样，循环会在线程睡眠前后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。

  1. /**
  2.  * 
  3.  */
  4. package demo2;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  9. /**
  10.  * @author liuchaojun
  11.  * @date 2018-12-13 下午06:50:25
  12.  */
  13. public class AwaitAndNotifyTest {
  14.     private int i;
  16.     public void end() {
  17.         System.out.println(Thread.currentThread().getName() + ":所有线程执行完毕!");
  18.     }
  20.     public synchronized void add() {
  21.         try {
  22.             while(i==1){
  23.                 wait();// 做完本线程等待    
  24.                 Thread.sleep(10);
  25.             }
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  29.         System.out.println(Thread.currentThread().getName() + ":" + (i++));
  30.         notifyAll();// 释放其他线程
  31.     }
  33.     public synchronized void remove() {
  35.         try {
  36.             while(i==0){
  37.                 wait();// 做完本线程等待    
  38.                 Thread.sleep(10);
  39.             }
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  43.         System.out.println(Thread.currentThread().getName() + ":" + (i--));
  44.         notifyAll();// 释放其他线程
  45.     }
  47.     public static void main(String[] args) {
  48.         AwaitAndNotifyTest c = new AwaitAndNotifyTest();
  49.         ExecutorService t = Executors.newFixedThreadPool(4);
  50.         for (int i = 0; i < 25; i++) {
  51.             t.execute(new Task1(c));
  52.             t.execute(new Task2(c));
  53.         }
  54.     }
  55. }
  57. class Task1 implements Runnable {
  59.     private AwaitAndNotifyTest awaitAndNotifyTest;
  61.     public Task1(AwaitAndNotifyTest awaitAndNotifyTest) {
  62.         super();
  63.         this.awaitAndNotifyTest = awaitAndNotifyTest;
  65.     }
  67.     /*
  68.      * (non-Javadoc)
  69.      * 
  70.      * @see java.lang.Runnable#run()
  71.      */
  72.     @Override
  73.     public void run() {
  74.         awaitAndNotifyTest.add();
  75.     }
  77. }
  79. class Task2 implements Runnable {
  80.     private AwaitAndNotifyTest awaitAndNotifyTest;
  82.     public Task2(AwaitAndNotifyTest awaitAndNotifyTest) {
  83.         super();
  84.         this.awaitAndNotifyTest = awaitAndNotifyTest;
  86.     }
  88.     /*
  89.      * (non-Javadoc)
  90.      * 
  91.      * @see java.lang.Runnable#run()
  92.      */
  93.     @Override
  94.     public void run() {
  95.         awaitAndNotifyTest.remove();
  96.     }
  98. }

20181214092801138.png

第二种方式使用ReentrantLock的锁，Condition等待和释放，具体操作看下面代码

这里excute和submit的方法在于

  1. 接收的参数不一样;

2.submit有返回值，而execute没有（返回一个future。可以用这个future来判断任务是否成功完成）

  1.         例如，有个validation的task，希望该task执行完后告诉我它的执行结果，是成功还是失败，然后继续下面的操作。

3.submit方便Exception处理

　　　例如，如果task里会抛出checked或者unchecked exception，而你又希望外面的调用者能够感知这些exception并做出及时的处理，那么就需要用到submit，通过对Future.get()进行抛出异常的捕获，然后对其进行处理。

  1. /**
  2.  * 
  3.  */
  4. package demo2;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.locks.Condition;
  9. import java.util.concurrent.locks.ReentrantLock;
  11. /**
  12.  * @author liuchaojun
  13.  * @date 2018-12-14 上午08:34:09
  14.  */
  15. public class ReentrantLockAndConditionTest {
  17.     private int i;
  18.     private ReentrantLock reentrantLock = new ReentrantLock();
  19.     private Condition condition = reentrantLock.newCondition();
  21.     public void end() {
  22.         System.out.println(Thread.currentThread().getName() + ":所有线程执行完毕!");
  23.     }
  25.     public  void add() {
  26.         try {
  27.             reentrantLock.lock();
  28.             while (i != 0) {
  29.                 condition.await();
  30.             }
  31.             System.out.println(Thread.currentThread().getName() + ":" + (i++));
  32.             condition.signalAll();
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } finally {
  36.             reentrantLock.unlock();
  37.         }
  38.     }
  40.     public  void remove() {
  41.         try {
  42.             reentrantLock.lock();
  43.             while (i != 1) {
  44.                 condition.await();
  46.             }
  47.             System.out.println(Thread.currentThread().getName() + ":" + (i--));
  48.             condition.signalAll();
  49.         } catch (InterruptedException e) {
  50.             e.printStackTrace();
  51.         } finally {
  52.             reentrantLock.unlock();
  53.         }
  55.     }
  57.     public static void main(String[] args) {
  58.         ReentrantLockAndConditionTest c = new ReentrantLockAndConditionTest();
  59.         ExecutorService t = Executors.newFixedThreadPool(4);
  60.         for (int i = 0; i < 5; i++) {
  61.             t.execute(new Task3(c));
  62.             t.execute(new Task4(c));
  63.         }
  64.         t.shutdown();
  65.     }
  66. }
  68. class Task3 implements Runnable {
  70.     private ReentrantLockAndConditionTest reentrantLockAndConditionTest;
  72.     public Task3(ReentrantLockAndConditionTest reentrantLockAndConditionTest) {
  73.         super();
  74.         this.reentrantLockAndConditionTest = reentrantLockAndConditionTest;
  76.     }
  78.     /*
  79.      * (non-Javadoc)
  80.      * 
  81.      * @see java.lang.Runnable#run()
  82.      */
  83.     @Override
  84.     public void run() {
  85.         reentrantLockAndConditionTest.add();
  86.     }
  88. }
  90. class Task4 implements Runnable {
  91.     private ReentrantLockAndConditionTest reentrantLockAndConditionTest;
  93.     public Task4(ReentrantLockAndConditionTest reentrantLockAndConditionTest) {
  94.         super();
  95.         this.reentrantLockAndConditionTest = reentrantLockAndConditionTest;
  97.     }
  99.     /*
  100.      * (non-Javadoc)
  101.      * 
  102.      * @see java.lang.Runnable#run()
  103.      */
  104.     @Override
  105.     public void run() {
  106.         reentrantLockAndConditionTest.remove();
  107.     }
  109. }

" class="reference-link">20181214092745465.png

第三种方式使用队列LinkedBlockingQueue

java.util.concurrent包下的新类。LinkedBlockingQueue就是其中之一，是一个阻塞的线程安全的队列，底层采用链表实现。

  1.   LinkedBlockingQueue构造的时候若没有指定大小，则默认大小为Integer.MAX\_VALUE，当然也可以在构造函数的参数中指定大小。LinkedBlockingQueue不接受null。
  3. 添加元素的方法有三个：add,put,offer,且这三个元素都是向队列尾部添加元素的意思。
  5. 区别:
  7.      add方法在添加元素的时候，若超出了度列的长度会直接抛出异常： 
  9.      put方法，若向队尾添加元素的时候发现队列已经满了会发生阻塞一直等待空间，以加入元素。 
  11.      offer方法在添加元素时，如果发现队列已满无法添加的话，会直接返回false。     
  13. 从队列中取出并移除头元素的方法有：poll，remove，take。     
  15.     poll: 若队列为空，返回null。
  17.     remove:若队列为空，抛出NoSuchElementException异常。
  19.     take:若队列为空，发生阻塞，等待有元素。

我们这里使用的是put和take方法，下面就是实现的代码。

  1. /**
  2.  * 
  3.  */
  4. package demo2;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.LinkedBlockingQueue;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * @author liuchaojun
  13.  * @date 2018-12-14 上午09:01:48
  14.  */
  15. public class LinkedBlockingQueueTest {
  17.     public static void main(String[] args) {
  18.         LinkedBlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();
  19.         ExecutorService t = Executors.newFixedThreadPool(4);
  20.         for (int i = 0; i < 5; i++) {
  21.             t.execute(new Task5(blockingQueue));
  22.             t.execute(new Task6(blockingQueue));
  23.         }
  24.         if (!t.isShutdown()) {
  25.             t.shutdown();
  26.             System.out.println("线程池停止接收外部任务！");
  27.             try {
  28.                 boolean flag = t.awaitTermination(300, TimeUnit.SECONDS);
  29.                 if (flag) {
  30.                     System.out.println("线程池已经停止！");
  31.                 }
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.         }
  37.     }
  38. }
  40. class Task5 implements Runnable {
  42.     private LinkedBlockingQueue blockingQueue;
  44.     public Task5(LinkedBlockingQueue blockingQueue) {
  45.         super();
  46.         this.blockingQueue = blockingQueue;
  48.     }
  50.     /*
  51.      * (non-Javadoc)
  52.      * 
  53.      * @see java.lang.Runnable#run()
  54.      */
  55.     @Override
  56.     public void run() {
  57.         try {
  58.             while (blockingQueue.size() < 1) {
  59.                 System.out.println(Thread.currentThread().getName()
  60.                         + ":生产者生产元素");
  61.                 blockingQueue.put("元素");
  62.             }
  63.         } catch (InterruptedException e) {
  64.             e.printStackTrace();
  65.         }
  66.     }
  68. }
  70. class Task6 implements Runnable {
  71.     private LinkedBlockingQueue blockingQueue;
  73.     public Task6(LinkedBlockingQueue blockingQueue) {
  74.         super();
  75.         this.blockingQueue = blockingQueue;
  77.     }
  79.     /*
  80.      * (non-Javadoc)
  81.      * 
  82.      * @see java.lang.Runnable#run()
  83.      */
  84.     @Override
  85.     public void run() {
  86.         try {
  87.             while (true) {
  88.                 System.out.println(Thread.currentThread().getName() + "消费者"
  89.                         + "消费:" + blockingQueue.take());
  91.             }
  92.         } catch (InterruptedException e) {
  93.             e.printStackTrace();
  94.         }
  95.     }
  97. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDI2NjAz_size_16_color_FFFFFF_t_70

其实线程通信有很多种，还有管道PipedOutputStream，计数countdownlatch等都可以实现，我这里写了三种作为示范。

发表评论

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

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

相关阅读