本篇文章为大家展示了怎么在java中利用多线程有序输出ABC，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

成都创新互联公司主要业务有网站营销策划、成都网站设计、网站建设、微信公众号开发、小程序设计、HTML5、程序开发等业务。一次合作终身朋友，是我们奉行的宗旨；我们不仅仅把客户当客户，还把客户视为我们的合作伙伴，在开展业务的过程中，公司还积累了丰富的行业经验、营销型网站资源和合作伙伴关系资源，并逐渐建立起规范的客户服务和保障体系。 

方式1：利用synchronized

这种方式也就是使用java内置的monitor机制，配合wait和notifyAll，代码如下：

（1）利用volatile做线程间资源的同步访问，同时作为线程调度的标志；
（2）利用notifyAll来唤醒其他等待当前的monitor资源的线程；

public class ThreadOrderWithSync {

  private volatile int flag = 'A';
  private final static Object LOCK = new Object();

  Runnable a = () -> {
    while (true) {
      synchronized (LOCK) {
        if (flag == 'A' ) {
          System.out.println("A");

          flag = 'B';
          // let other thread race to get the monitor
          LOCK.notifyAll();
        } else {
          try {
            LOCK.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }
  };

  Runnable b = () -> {
    while (true) {
      synchronized (LOCK) {
        if (flag == 'B' ) {
          System.out.println("B");

          flag = 'C';
          // let other thread race to get the monitor
          LOCK.notifyAll();
        } else {
          try {
            LOCK.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }
  };

  Runnable c = () -> {
    while (true) {
      synchronized (LOCK) {
        if (flag == 'C' ) {
          System.out.println("C");

          flag = 'A';
          // let other thread race to get the monitor
          LOCK.notifyAll();
        } else {
          try {
            LOCK.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }
  };

  public void runTest() {
    Thread ta = new Thread(a);
    Thread tb = new Thread(b);
    Thread tc = new Thread(c);

    ta.start();
    tb.start();
    tc.start();
  }

  public static void main(String[] args) {
    ThreadOrderWithSync sync = new ThreadOrderWithSync();
    sync.runTest();
  }
}

方式2：利用并发包ReentrantLock和Condition的锁机制

上面方式1的synchronized机制，因为当前的所有线程都争用同一个monitor资源，因此只能通过notifyAll来通知其他线程来加锁，因此每次都会出现race condition，但是，通过ReentrantLock的Condition，我们可以精确控制，下一个该唤醒signal的线程是哪一个(因为我们知道执行的顺序是A->B->C的循环)，相比synchronized的机制，Condition机制可以更精细化线程的调度设计，代码示例如下：

/**
 * @author xijin.zeng created on 2018/8/31
 * Thrads runing order: A->B->C
 */
public class ThreadOrderWithCondition {

  private static final ReentrantLock LOCK = new ReentrantLock();
  private static final Condition C_A = LOCK.newCondition();
  private static final Condition C_B = LOCK.newCondition();
  private static final Condition C_C = LOCK.newCondition();

  /**
   * init for A to run first
   */
  private volatile int flag = 'A';

  Runnable a = () -> {
    while (true) {
      LOCK.lock();

      if (flag == 'A') {
        System.out.println("A");
        flag = 'B';
        // signal B to run
        C_B.signal();
      } else {
        try {
          // block and wait signal to invoke
          C_A.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }

      LOCK.unlock();
    }
  };

  Runnable b = () -> {
    while (true) {
      LOCK.lock();

      if (flag == 'B') {
        System.out.println("B");
        flag = 'C';
        // signal C to run
        C_C.signal();
      } else {
        try {
          // block and wait signal to invoke
          C_B.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }

      LOCK.unlock();
    }
  };

  Runnable c = () -> {
    while (true) {
      LOCK.lock();

      if (flag == 'C') {
        System.out.println("C");
        flag = 'A';
        // signal A to run
        C_A.signal();
      } else {
        try {
          // block and wait signal to invoke
          C_C.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }

      LOCK.unlock();
    }
  };

  public void runTest() {
    Thread threadA = new Thread(a);
    Thread threadB = new Thread(b);
    Thread threadC = new Thread(c);

    threadA.start();
    threadB.start();
    threadC.start();
  }

  public static void main(String[] args) {
    ThreadOrderWithCondition o = new ThreadOrderWithCondition();
    o.runTest();
  }
}

上述内容就是怎么在java中利用多线程有序输出ABC，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注创新互联行业资讯频道。

分享名称：怎么在java中利用多线程有序输出ABC
文章起源：http://www.cqwzjz.cn/article/pigooi.html