书上给的例子都是ABCABC这种,比较简单,复杂点的如A0B0C0, A0A1A2没有,手动实现下,做个记录

1. A0 A1 A2 A3

  1.  public class Demo0 {
  2.  
  3.      private static volatile  int nextPrintWho = 0;
  4.  
  5.      public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
  6.          ReentrantLock lock = new ReentrantLock();
  7.          Condition condition = lock.newCondition();
  8.  
  9.          Runnable runnable = ()-> {
  10.              lock.lock();
  11.              String name = Thread.currentThread().getName();
  12.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  13.              while (Demo0.nextPrintWho != index) {
  14.                  try {
  15.                      condition.await();
  16.                  } catch (InterruptedException e) {
  17.                      e.printStackTrace();
  18.                  }
  19.              }
  20.              Demo0.nextPrintWho += 1;
  21.              println(Thread.currentThread().getName());
  22.              try {
  23.                  condition.signAll();
  24.              }catch (Exception e) {
  25.                  e.printStackTrace();
  26.              }finally {
  27.                  if(lock.isHeldByCurrentThread()) {
  28.                      lock.unlock();
  29.                  }
  30.              }
  31.          };
  32.          int size = 5;
  33.          List<Thread> threadList = new ArrayList<>(size);
  34.          for(int i=0; i<size; i++) {
  35.              threadList.add(new Thread(runnable,"A" + i));
  36.          }
  37.          threadList.forEach(i->i.start());
  38.      }
  39.  
  40.      private static void println(Object object) {
  41.          System.out.println(object);
  42.      }
  43.  
  44.  }

2.单condition实现ABC ABC ABC

  1.  /**
  2.   * @author tele
  3.   * @Description     使用condition实现顺序启动线程 ABC ABC ABC
  4.   * @create 2019-12-24
  5.   */
  6.  public class Demo1 {
  7.  
  8.      private static volatile  int nextPrintWho = 1;
  9.  
  10.      public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
  11.          ReentrantLock lock = new ReentrantLock();
  12.          Condition condition = lock.newCondition();
  13.  
  14.          Runnable runnableA = ()-> {
  15.              lock.lock();
  16.              while (Demo1.nextPrintWho != 1) {
  17.                  try {
  18.                      condition.await();
  19.                  } catch (InterruptedException e) {
  20.                      e.printStackTrace();
  21.                  }
  22.              }
  23.              Demo1.nextPrintWho = 2;
  24.              println(Thread.currentThread().getName());
  25.              try {
  26.                  condition.signAll();
  27.              }catch (Exception e) {
  28.                  e.printStackTrace();
  29.              }finally {
  30.                  if(lock.isHeldByCurrentThread()) {
  31.                      lock.unlock();
  32.                  }
  33.              }
  34.          };
  35.  
  36.          Runnable runnableB = ()-> {
  37.              lock.lock();
  38.              while (Demo1.nextPrintWho != 2) {
  39.                  try {
  40.                      condition.await();
  41.                  } catch (InterruptedException e) {
  42.                      e.printStackTrace();
  43.                  }
  44.              }
  45.              Demo1.nextPrintWho = 3;
  46.              println(Thread.currentThread().getName());
  47.              try {
  48.                  condition.signal();
  49.              }catch (Exception e) {
  50.                  e.printStackTrace();
  51.              }finally {
  52.                  if(lock.isHeldByCurrentThread()) {
  53.                      lock.unlock();
  54.                  }
  55.              }
  56.          };
  57.  
  58.          Runnable runnableC = ()-> {
  59.              lock.lock();
  60.              while (Demo1.nextPrintWho != 3) {
  61.                  try {
  62.                      condition.await();
  63.                  } catch (InterruptedException e) {
  64.                      e.printStackTrace();
  65.                  }
  66.              }
  67.              Demo1.nextPrintWho = 1;
  68.              println(Thread.currentThread().getName());
  69.              try {
  70.                  condition.signal();
  71.              }catch (Exception e) {
  72.                  e.printStackTrace();
  73.              }finally {
  74.                  if(lock.isHeldByCurrentThread()) {
  75.                      lock.unlock();
  76.                  }
  77.              }
  78.          };
  79.  
  80.          for(int i=0; i<5; i++) {
  81.              new Thread(runnableA,"A").start();
  82.              new Thread(runnableB,"B").start();
  83.              new Thread(runnableC,"C").start();
  84.          }
  85.  
  86.      }
  87.  
  88.      private static void println(Object object) {
  89.          System.out.println(object);
  90.      }
  91.  
  92.  }

3.多个condition实现ABC ABC

  1.  /**
  2.   * @author tele
  3.   * @Description     使用多个condition实现顺序启动线程  ABC ABC ABC
  4.   * @create 2019-12-24
  5.   */
  6.  public class Demo2 {
  7.  
  8.      private static volatile  int nextPrintWho = 1;
  9.  
  10.      public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
  11.          ReentrantLock lock = new ReentrantLock();
  12.          Condition conditionA = lock.newCondition();
  13.          Condition conditionB = lock.newCondition();
  14.          Condition conditionC = lock.newCondition();
  15.  
  16.          Runnable runnableA = ()-> {
  17.              lock.lock();
  18.              while (Demo2.nextPrintWho != 1) {
  19.                  try {
  20.                      conditionA.await();
  21.                  } catch (InterruptedException e) {
  22.                      e.printStackTrace();
  23.                  }
  24.              }
  25.              Demo2.nextPrintWho = 2;
  26.              println(Thread.currentThread().getName());
  27.              try {
  28.                  conditionB.signal();
  29.               }catch (Exception e) {
  30.                  e.printStackTrace();
  31.              }finally {
  32.                  if(lock.isHeldByCurrentThread()) {
  33.                      lock.unlock();
  34.                  }
  35.              }
  36.          };
  37.  
  38.          Runnable runnableB = ()-> {
  39.              lock.lock();
  40.              while (Demo2.nextPrintWho != 2) {
  41.                  try {
  42.                      conditionB.await();
  43.                  } catch (InterruptedException e) {
  44.                      e.printStackTrace();
  45.                  }
  46.              }
  47.              Demo2.nextPrintWho = 3;
  48.              println(Thread.currentThread().getName());
  49.              try {
  50.                  conditionC.signal();
  51.              }catch (Exception e) {
  52.                  e.printStackTrace();
  53.              }finally {
  54.                  if(lock.isHeldByCurrentThread()) {
  55.                      lock.unlock();
  56.                  }
  57.              }
  58.          };
  59.  
  60.          Runnable runnableC = ()-> {
  61.              lock.lock();
  62.              while (Demo2.nextPrintWho != 3) {
  63.                  try {
  64.                      conditionC.await();
  65.                  } catch (InterruptedException e) {
  66.                      e.printStackTrace();
  67.                  }
  68.              }
  69.              Demo2.nextPrintWho = 1;
  70.              println(Thread.currentThread().getName());
  71.              try {
  72.                  conditionA.signal();
  73.              }catch (Exception e) {
  74.                  e.printStackTrace();
  75.              }finally {
  76.                  if(lock.isHeldByCurrentThread()) {
  77.                      lock.unlock();
  78.                  }
  79.              }
  80.          };
  81.  
  82.          for(int i=0; i<5; i++) {
  83.              new Thread(runnableA,"A").start();
  84.              new Thread(runnableB,"B").start();
  85.              new Thread(runnableC,"C").start();
  86.          }
  87.  
  88.      }
  89.  
  90.      private static void println(Object object) {
  91.          System.out.println(object);
  92.      }
  93.  
  94.  }

4.A0 B0 C0 A1 B1 C1 A2 B2 C2

  1.  /**
  2.   * @author tele
  3.   * @Description     使用condition实现顺序启动线程  A0 B0 C0 A1 B1 C1 A2 B2 C2
  4.   * @create 2019-12-24
  5.   */
  6.  public class Demo3 {
  7.  
  8.      private static volatile  int nextPrintWho = 0;
  9.  
  10.      private static volatile int order = 1;
  11.  
  12.      private static final int ORDER_A = 1;
  13.  
  14.      private static final int ORDER_B = 2;
  15.  
  16.      private static final int ORDER_C = 3;
  17.  
  18.      public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
  19.          ReentrantLock lock = new ReentrantLock();
  20.          Condition conditionA = lock.newCondition();
  21.          Condition conditionB = lock.newCondition();
  22.          Condition conditionC = lock.newCondition();
  23.  
  24.          Runnable runnableA = ()-> {
  25.              lock.lock();
  26.              String name = Thread.currentThread().getName();
  27.  
  28.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  29.  
  30.              while (!name.contains("A") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_A) {
  31.                  try {
  32.                      conditionA.await();
  33.                  } catch (InterruptedException e) {
  34.                      e.printStackTrace();
  35.                  }
  36.              }
  37.  
  38.              Demo3.order = Demo3.ORDER_B;
  39.              println(Thread.currentThread().getName());
  40.              try {
  41.                  conditionB.signalAll();
  42.              }catch (Exception e) {
  43.                  e.printStackTrace();
  44.              }finally {
  45.                  if(lock.isHeldByCurrentThread()) {
  46.                      lock.unlock();
  47.                  }
  48.              }
  49.          };
  50.  
  51.          Runnable runnableB = ()-> {
  52.              lock.lock();
  53.              String name = Thread.currentThread().getName();
  54.  
  55.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  56.  
  57.              while (!name.contains("B") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_B) {
  58.                  try {
  59.                      conditionB.await();
  60.                  } catch (InterruptedException e) {
  61.                      e.printStackTrace();
  62.                  }
  63.              }
  64.              Demo3.order = Demo3.ORDER_C;
  65.              println(Thread.currentThread().getName());
  66.              try {
  67.                  conditionC.signalAll();
  68.              }catch (Exception e) {
  69.                  e.printStackTrace();
  70.              }finally {
  71.                  if(lock.isHeldByCurrentThread()) {
  72.                      lock.unlock();
  73.                  }
  74.              }
  75.          };
  76.  
  77.          Runnable runnableC = ()-> {
  78.              lock.lock();
  79.              String name = Thread.currentThread().getName();
  80.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  81.              while (!name.contains("C") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_C) {
  82.                  try {
  83.                      conditionC.await();
  84.                  } catch (InterruptedException e) {
  85.                      e.printStackTrace();
  86.                  }
  87.              }
  88.              Demo3.nextPrintWho += 1;
  89.              Demo3.order = Demo3.ORDER_A;
  90.              println(Thread.currentThread().getName());
  91.              try {
  92.                  conditionA.signalAll();
  93.              }catch (Exception e) {
  94.                  e.printStackTrace();
  95.              }finally {
  96.                  if(lock.isHeldByCurrentThread()) {
  97.                      lock.unlock();
  98.                  }
  99.              }
  100.          };
  101.  
  102.          for(int i=0; i<5; i++) {
  103.              new Thread(runnableA,"A" + i).start();
  104.              new Thread(runnableB,"B" + i).start();
  105.              new Thread(runnableC,"C" + i).start();
  106.          }
  107.  
  108.      }
  109.  
  110.      private static void println(Object object) {
  111.          System.out.println(object);
  112.      }
  113.  
  114.  }

5.A0 A1 A2 A3 B0 B1 B2 B3

  1.  /**
  2.   * @author tele
  3.   * @Description     使用condition实现顺序启动线程 A0 A1 A2 A3 B0 B1 B2 B3
  4.   * @create 2019-12-24
  5.   */
  6.  public class Demo4 {
  7.  
  8.      private static volatile  int nextPrintWho = 0;
  9.  
  10.      private static volatile int order = 1;
  11.  
  12.      private static final int LIST_SIZE = 5;
  13.  
  14.      private static final int ORDER_A = 1;
  15.  
  16.      private static final int ORDER_B = 2;
  17.  
  18.      private static final int ORDER_C = 3;
  19.  
  20.      public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
  21.          ReentrantLock lock = new ReentrantLock();
  22.          Condition condition = lock.newCondition();
  23.          Runnable runnableA = ()-> {
  24.              lock.lock();
  25.              String name = Thread.currentThread().getName();
  26.  
  27.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  28.  
  29.              while (!name.contains("A") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_A) {
  30.                  try {
  31.                      condition.await();
  32.                  } catch (InterruptedException e) {
  33.                      e.printStackTrace();
  34.                  }
  35.              }
  36.              Demo4.nextPrintWho += 1;
  37.              if(Demo4.nextPrintWho == LIST_SIZE) {
  38.                  Demo4.order = Demo4.ORDER_B;
  39.                  Demo4.nextPrintWho = 0;
  40.              }
  41.              println(Thread.currentThread().getName());
  42.              try {
  43.                  condition.signalAll();
  44.              }catch (Exception e) {
  45.                  e.printStackTrace();
  46.              }finally {
  47.                  if(lock.isHeldByCurrentThread()) {
  48.                      lock.unlock();
  49.                  }
  50.              }
  51.          };
  52.  
  53.          Runnable runnableB = ()-> {
  54.              lock.lock();
  55.              String name = Thread.currentThread().getName();
  56.  
  57.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  58.  
  59.              while (!name.contains("B") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_B) {
  60.                  try {
  61.                      condition.await();
  62.                  } catch (InterruptedException e) {
  63.                      e.printStackTrace();
  64.                  }
  65.              }
  66.              Demo4.nextPrintWho += 1;
  67.              if(Demo4.nextPrintWho == LIST_SIZE) {
  68.                  Demo4.order = Demo4.ORDER_C;
  69.                  Demo4.nextPrintWho = 0;
  70.              }
  71.              println(Thread.currentThread().getName());
  72.              try {
  73.                  condition.signalAll();
  74.              }catch (Exception e) {
  75.                  e.printStackTrace();
  76.              }finally {
  77.                  if(lock.isHeldByCurrentThread()) {
  78.                      lock.unlock();
  79.                  }
  80.              }
  81.          };
  82.  
  83.          Runnable runnableC = ()-> {
  84.              lock.lock();
  85.              String name = Thread.currentThread().getName();
  86.              final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
  87.              while (!name.contains("C") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_C) {
  88.                  try {
  89.                      condition.await();
  90.                  } catch (InterruptedException e) {
  91.                      e.printStackTrace();
  92.                  }
  93.              }
  94.              Demo4.order = Demo4.ORDER_C;
  95.              Demo4.nextPrintWho += 1;
  96.              println(Thread.currentThread().getName());
  97.              try {
  98.                  condition.signalAll();
  99.              }catch (Exception e) {
  100.                  e.printStackTrace();
  101.              }finally {
  102.                  if(lock.isHeldByCurrentThread()) {
  103.                      lock.unlock();
  104.                  }
  105.              }
  106.          };
  107.  
  108.          List<Thread> threadAList = new ArrayList<>(LIST_SIZE);
  109.          List<Thread> threadBList = new ArrayList<>(LIST_SIZE);
  110.          List<Thread> threadCList = new ArrayList<>(LIST_SIZE);
  111.  
  112.          for(int i=0; i<LIST_SIZE; i++) {
  113.              threadAList.add(new Thread(runnableA,"A" + i));
  114.              threadBList.add(new Thread(runnableB,"B" + i));
  115.              threadCList.add(new Thread(runnableC,"C" + i));
  116.          }
  117.  
  118.          threadAList.forEach(i->i.start());
  119.          threadBList.forEach(i->i.start());
  120.          threadCList.forEach(i->i.start());
  121.  
  122.      }
  123.  
  124.      private static void println(Object object) {
  125.          System.out.println(object);
  126.      }
  127.  
  128.  }

使用condition 实现线程顺序执行的更多相关文章

  1. Java中如何保证线程顺序执行

    只要了解过多线程,我们就知道线程开始的顺序跟执行的顺序是不一样的.如果只是创建三个线程然后执行,最后的执行顺序是不可预期的.这是因为在创建完线程之后,线程执行的开始时间取决于CPU何时分配时间片,线程 ...

  2. Android中让多个线程顺序执行探究

    线程调度是指按照特定机制为多个线程分配CPU的使用权. 有两种调度模型:分时调度模型和抢占式调度模型. 分时调度模型:是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片. ...

  3. T1，T2，T3 三个线程顺序执行

    T1,T2,T3 三个线程顺序执行 现在有 T1.T2.T3 三个线程,你怎样保证 T2 在 T1 执行完后执行,T3 在 T2 执行完后执行?(T1->T2->T3) 这个线程问题通常会 ...

  4. c#线程顺序执行

    using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threa ...

  5. Java中线程顺序执行

    现有线程threadone.threadtwo和threadthree,想要的运行顺序为threadone->threadtwo->threadthree,应该如何处理?这里需要用到一个简 ...

  6. 三个线程T1,T2,T3.保证顺序执行的三种方法

    经常看见面试题:有三个线程T1,T2,T3,有什么方法可以确保它们按顺序执行.今天手写测试了一下,下面贴出目前想到的3种实现方式 说明:这里在线程中我都用到了sleep方法,目的是更容易发现问题.之前 ...

  7. 三个线程abc顺序执行

    1.使用synchronized悲观锁(秋招阿里的一个笔试题,应该写的比较复杂,然后就没有然后了o(╥﹏╥)o) public class ThreadThreadp { private int fl ...

  8. C#之使用AutoResetEvent实现线程的顺序执行

    前几天一朋友问我如何实现线程的顺序执行,说真的,虽然看过CLR这本书,也把线程部分拜读了两遍,但是这个问题出来之后还是没有一个思路.今天在搜索资料的时候无意中再次看到AutoResetEvent这个东 ...

  9. Qt 控制线程的顺序执行（使用QWaitCondition，并且线程类的run函数里记得加exec(),使得线程常驻）

    背景项目中用到多线程,对线程的执行顺序有要求: A.一个线程先收数据 B.一个线程处理数据 C.一个线程再将处理后的数据发送出去 要求三个线程按照ABC的顺序循环执行. 思路子类化多线程方法 重写子类 ...

随机推荐

  1. 《第一行代码》之——1.Android简介

    Android简介 Android系统架构 (图片源自维基百科) Android大致分为四层架构,五块区域. Linux内核层 Android系统基于Linux2.6,这一层为Android设备的各种 ...

  2. 【错误收集】SVN冲突解决 标签： 错误收集 2016-03-13 08:44 624人阅读 评论(24) 收藏

    最近在倒代码,这真的是一件挺低效率的事情的,但是为了之后工作的进行,必须把这些已经做好的界面,做好的功能搬到新的框架上来,所以安排了10来个同学一起倒代码,因为大家共用一个解决方案,所以使用svn来进 ...

  3. ACK容器服务发布virtual node addon，快速部署虚拟节点提升集群弹性能力

    在上一篇博文中(https://yq.aliyun.com/articles/647119),我们展示了如何手动执行yaml文件给Kubernetes集群添加虚拟节点,然而,手动执行的方式用户体验并不 ...

  4. 在window.onload中使用setTimeout

    window.onload = function(){ function n(i){ alert(1); } setTimeout('n(1)',2000); } 以上代码会报错:n() is not ...

  5. 基于GIS的空间分析功能分析芝加哥小熊队和白袜队的球迷范围

    将交换格式的文件转换为要素类 在ArcCatalog中新建地址定位器 设置地址定位器的样式 选择Arctoolbox->地理编码工具->对地址进行地理编码 定义坐标系 定义坐标系后如图所示 ...

  6. mysql列转行 行转列

    列转行 SELECT flag ,substring_index(substring_index(t.context,), ) as result FROM ( select 'aa' as flag ...

  7. 快速完成智能数据构建，Dataphin公共云版本全面解读

    公测两个月,Dataphin公共云版本已经受到了阿里云上众多轻量级用户的关注.事实上,Dataphin作为一款大数据智能构建与管理的产品,其核心功能是面向各行各业大数据建设.管理及应用诉求,一站式提供 ...

  8. 爬虫：Selenium + PhantomJS

    更:Selenium特征过多(language/UserAgent/navigator/en-US/plugins),以Selenium打开的浏览器处于自测模式,很容易被检测出来,解决方法可选: 用m ...

  9. C#设置Excel行高、列宽

    设置固定值 worksheet.Columns[1].ColumnWidth = 15; 设置自动换行 worksheet.Columns.WrapText = true; 设置自动行高.列宽 xlA ...

  10. MapReduce数据流-Reduce