ABC三个线程顺序执行（简单实现）

最新推荐文章于 2024-06-11 10:37:49 发布
最新推荐文章于 2024-06-11 10:37:49 发布
阅读量9.9k 收藏 22
点赞数 3
分类专栏： Java基础/API 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41933709/article/details/94178987
版权

需求：3个线程 输出ABC ------> ABCABCABC。。。。。此类型
ps：2020-12-19 更新了6种

 

1、 使用线程池 将所有线程放入一个队列 ，保证顺序输出

public class ThreeThread {
    
    public static void main(String[] args) throws InterruptedException {

        //用线程池来实现 ，3个线程加入线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            pool.submit(()-> System.out.println("A"));
            pool.submit(()-> System.out.println("B"));
            pool.submit(()-> System.out.println("C"));
        }
        pool.shutdown();

    }

}

2、java.util.concurrent.atomic.AtomicInteger 保证原子操作

/**.
 * Created by: yuqiang
 * Date: 2020/12/18 10:54
 * Description: java.util.concurrent.atomic.AtomicInteger 控制
 */
public class Foo {

  private AtomicInteger flag = new AtomicInteger(1);

  public Foo() { }

  public void first(String str) throws InterruptedException {
    while(flag.get()%3 != 1){    };
    System.out.println(str);
    flag.incrementAndGet();
  }

  public void second(String str) throws InterruptedException {
    while(flag.get()%3 != 2){    };
    System.out.println(str);
    flag.incrementAndGet();

  }

  public void third(String str) throws InterruptedException {
    while(flag.get()%3 != 0){    };
    System.out.println(str);
    flag.incrementAndGet();
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();
    new Thread(()->{
      try {
        for (int i = 0; i < 3; i++) {
          Thread.sleep(100);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 3; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 3; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

  }
  
}

3、volatile 控制flag在并发环境中可见

/**.
 * Created by:yuqiang
 * Date: 2020/12/18 10:54
 * Description: volatile 控制flag在并发环境中可见
 */
public class Foo {

  private volatile int flag = 1;

  public Foo() {

  }

  public void first(String str) throws InterruptedException {
    while(flag%3 != 1){
    };
    System.out.println(str);
    flag++;
  }

  public void second(String str) throws InterruptedException {
    while(flag%3 != 2){
    };
    System.out.println(str);
    flag++;

  }

  public void third(String str) throws InterruptedException {
    while(flag%3 != 0){
    };
    System.out.println(str);
    System.out.println("==============");
    flag++;
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(500);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();



    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

  }

}

4、synchronized  wait() notifyAll() 控制

/**
 * Created by: e-yuqiang1
 * Date: 2020/12/18 10:54
 * Description: synchronized  wait() notifyAll()
 */
public class Foo {

  private int flag = 1;

  public Foo() {

  }

  public synchronized void first(String str) throws InterruptedException {
    while(flag%3 != 1){
      wait();
    };
    System.out.println(str);
    flag++;
    notifyAll();
  }

  public synchronized void second(String str) throws InterruptedException {
    while(flag%3 != 2){
      wait();
    };
    System.out.println(str);
    flag++;
    notifyAll();
  }

  public synchronized void third(String str) throws InterruptedException {
    while(flag%3 != 0){
      wait();
    };
    System.out.println(str);
    System.out.println("=====================");
    flag++;
    notifyAll();
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(500);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }
  
}

5、LockReentrantLock Condition(await(),signalAll()) 控制

/**
 * Created by: e-yuqiang1
 * Date: 2020/12/18 10:54
 * Description:
 */
public class Foo {

  private int flag = 1;

  private Lock lock;
  private Condition condition;

  public Foo() {
    lock = new ReentrantLock();
    condition = lock.newCondition();
  }

  public void first(String str) throws InterruptedException {
    lock.lock();
    try {
      while(flag%3 != 1){
        condition.await();
      }
      System.out.println(str);
      flag++;
      condition.signalAll();
    } finally {
      lock.unlock();
    }

  }

  public void second(String str) throws InterruptedException {
    lock.lock();
    try {
      while(flag%3 != 2){
        condition.await();
      }
    System.out.println(str);
    flag++;
    condition.signalAll();
    } finally {
      lock.unlock();
    }
  }

  public void third(String str) throws InterruptedException {
    lock.lock();
    try {
      while(flag%3 != 0){
        condition.await();
      }
    System.out.println(str);
    System.out.println("=====================");
    flag++;
    condition.signalAll();
  } finally {
    lock.unlock();
  }
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(500);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }

}

6、信号量 semaphore(.acquire() .release())

/**
 * Created by: e-yuqiang1
 * Date: 2020/12/18 10:54
 * Description:
 */
public class Foo {


  private Semaphore semaphoreA;
  private Semaphore semaphoreB;
  private Semaphore semaphoreC;

  public Foo() throws InterruptedException {
    semaphoreA = new Semaphore(1);
    semaphoreB = new Semaphore(1);
    semaphoreC = new Semaphore(1);
    semaphoreB.acquire();//提前请求B
    semaphoreC.acquire();//提前请求C
  }

  public void first(String str) throws InterruptedException {
    semaphoreA.acquire();
    System.out.println(str);
    semaphoreB.release();
  }

  public void second(String str) throws InterruptedException {
    semaphoreB.acquire();
    System.out.println(str);
    semaphoreC.release();
  }

  public void third(String str) throws InterruptedException {
    semaphoreC.acquire();
    System.out.println(str);
    System.out.println("=====================");
    semaphoreA.release();
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(1000);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }

}

7、CountDownLatch(.await() .countDown())  计数器(减法) 

  ps：感觉比较取巧 不推荐这种写法

/**
 * Created by: e-yuqiang1
 * Date: 2020/12/18 10:54
 * Description: 写的挺Low的 试了半个小时
 */
public class Foo {


  private CountDownLatch countDownLatchA;
  private CountDownLatch countDownLatchB;
  private CountDownLatch countDownLatchC;

  public Foo() throws InterruptedException {
    countDownLatchA = new CountDownLatch(1);
    countDownLatchB = new CountDownLatch(1);
    countDownLatchC = new CountDownLatch(1);
    countDownLatchA.countDown();
  }

  public void first(String str) throws InterruptedException {
    countDownLatchA.await();
    System.out.println(str);
    countDownLatchA= new CountDownLatch(1);
    countDownLatchB.countDown();
  }

  public void second(String str) throws InterruptedException {
    countDownLatchB.await();
    System.out.println(str);
    countDownLatchB = new CountDownLatch(1);
    countDownLatchC.countDown();
  }

  public void third(String str) throws InterruptedException {
    countDownLatchC.await();
    System.out.println(str);
    System.out.println("=====================");
    countDownLatchC = new CountDownLatch(1);
    countDownLatchA.countDown();
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }

}

8、BlockingQueue(.take() .put()) 阻塞队列控制

/**
 * Created by: e-yuqiang1
 * Date: 2020/12/18 10:54
 * Description: BlockingQueue 阻塞队列
 */
public class Foo {


  private BlockingQueue<Integer> blockingQueueA;
  private BlockingQueue<Integer> blockingQueueB;
  private BlockingQueue<Integer> blockingQueueC;


  public Foo() throws InterruptedException {
    blockingQueueA = new ArrayBlockingQueue<>(1);
    blockingQueueB = new ArrayBlockingQueue<>(1);
    blockingQueueC = new ArrayBlockingQueue<>(1);
    blockingQueueA.put(1);
  }

  public void first(String str) throws InterruptedException {
    blockingQueueA.take();
    System.out.println(str);
    blockingQueueB.put(2);
  }

  public void second(String str) throws InterruptedException {
    blockingQueueB.take();
    System.out.println(str);
    blockingQueueC.put(3);
  }

  public void third(String str) throws InterruptedException {
    blockingQueueC.take();
    System.out.println(str);
    System.out.println("=====================");
    blockingQueueA.put(1);
  }

  public static void main(String[] args) throws InterruptedException {
    Foo foo = new Foo();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(500);
          foo.second("B");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          Thread.sleep(300);
          foo.first("A");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();

    new Thread(()->{
      try {
        for (int i = 0; i < 10; i++) {
          foo.third("C");
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }).start();
  }

}

目前想到了只有这8种......

 

 

Crayon_Yu
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java多线程每个线程挨着打印ABC的4种实现方式
08-23
java多线程每个线程挨着打印ABC的4种实现方式，有4个线程t1、t2、t3、t4，t1打印A后t2打印A再t3打印A再t4打印A，然后从新回到t1打印B再t2打印B...t4打印B... 4个线程轮流打印abc... 一个线程可以理解为一个人，打印...
面试的时候，遇到一个问题。我三个任务，ABC，我怎么让A执行完执行B，B执行完执行C 3个并行线程，如何解决。程池的核心运行原理和参数。
aq_money的博客
08-29 451
是 Java 标准库中的一个同步工具，用于在多个线程之间进行协调和控制。它可以帮助一个或多个线程等待其他线程完成一组操作，然后再继续执行。你可以将想象成一个倒计时计数器，可以设置一个初始计数值，然后多个线程可以等待这个计数器减为零，之后再继续执行。await()方法：调用这个方法的线程会被阻塞，直到计数器减到零。其他线程完成一定操作后，调用方法来减小计数器的值。当计数器变为零时，被阻塞的线程会继续执行。方法：这个方法用于减小计数器的值。当一个线程完成了一个操作，可以调用这个方法来减小计数器的值。
实现三个线程A、B、C顺序执行
kyrielx的博客
11-27 772
实现三个线程A、B、C顺序执行
java三个线程如何做到顺序执行
最新发布
weixin_39304656的博客
06-11 457
在 Java 中，要控制三个线程的执行顺序，可以使用多种方法，其中包括使用wait和notify机制，，以及Semaphore等。下面我将展示这些方法的具体实现。
【Java】有 A、B、C 三个线程，如何保证三个线程同时执行？在并发情况下，如何保证三个线程依次执行？如何保证三个线程有序交错执行？
Siona_xin 的博客
03-18 953
多个线程执行
线程顺序执行的8种方法，最后一种你用过吗？
张小凡
08-20 8565
面试官：3个线程，按顺序先后执行？
如何实现ABC三个线程按顺序执行十次
张维鹏的博客
09-26 1万+
题目要求：创建三个线程，每个线程分别打印ABC，并按照ABC的顺序执行十次 题目可以使用多种不同的方式解决，下面我们分别使用 Condition 等待唤醒机制、Semaphore 信号量、CountDownLatch 闭锁、Thread.join() 方法四种方式实现题目要求。 一、使用一个 ReentrantLock 和 三个 Condition 来实现： import java.util.concurrent.locks.Condition; import java.util.concurr
如何保证线程A,B,C顺序执行，或者C在A、B后执行？
DU9999999的博客
12-17 730
线程A,B,C顺序执行的解决方案
面试题：有A,B,C三个线程，如何保证三个线程同时执行?如何在并发情况下保证三个线程依次执行?如何保证二个线程有序交错进行?
匿迹
04-09 3915
面试题：有A,B,C三个线程，如何保证三个线程同时执行?如何在并发情况下保证三个线程依次执行?如何保证二个线程有序交错进行?面试题：有A,B,C三个线程，如何保证三个线程同时执行?如何在并发情况下保证三个线程依次执行?如何保证二个线程有序交错进行?有A,B,C三个线程，如何保证三个线程同时执行?有A,B,C三个线程，如何在并发情况下保证三个线程依次执行?有A,B,C三个线程，如何保证三个线程有序交错进行? 面试题：有A,B,C三个线程，如何保证三个线程同时执行?如何在并发情况下保证三个线程依次执行?如何保证
如何确保三个线程顺序执行？
sushuiyuzhou的专栏
05-17 3548
场景：有三个线程t1、t2、t3。确保三个线程t1执行完后t2执行，t2执行完成后t3执行。 1.使用join thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 t.join(); //调用join方法，等待线程t执行完毕 t.join(1000); //等待 t 线程，等待时间是1000毫秒。 public class ThreadTest1...
Java多线程连续打印abc实现方法详解
08-19
Java多线程连续打印abc实现方法详解是 Java 编程语言中的一种常见问题，旨在解决三个线程同时执行，要求打印出10个连着的abc的难题。该问题的解决方案需要使用同步机制来确保三个线程的顺序执行。 知识点一：多线程...
java多线程实现有序输出ABC
08-25
java多线程实现有序输出ABC是java多线程编程中的一种常见问题，它的本质是控制线程的执行顺序，实现线程之间的同步和通信。在java中，可以使用多种方式来实现多线程的有序输出，以下我们将详细介绍两种常见的实现...
java代码-三个线程轮流输出abc
07-16
在这个问题中，有三个线程分别代表A、B、C三个角色，它们需要按照特定顺序（ABC、BCA、CAB、...）交替打印字符。为了实现这个功能，开发者通常会用到Java的线程同步机制，如synchronized关键字、wait()和notify()...
Java 指定A B C 三个线程顺序执行
风云无忌的博客
03-10 1310
本文示例代码在目录下今天面试遇到这个问题,A、B、C三个线程，如何让他们按照顺序执行。当时没想起来怎么说，后来百度了下，发现实现有好几种方式可以使用。
三个线程交替顺序打印ABC
热门推荐
洞玄之境的博客
09-10 2万+
题目描述 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。 5种方法 使用synchronized, wait和notifyAll 使用Lock-&amp;gt;ReentrantLock 和 state标志 使用Lock-&amp;gt;ReentrantLock 和Con...
三个线程按顺序执行
萧少
04-17 1538
###现有三个线程,如何让它们按照顺序执行 第一种方法① 使用 Thread.join() 方法 package com.home.demo.th; /** @author XWX 需求: 现在有三个线程,让它们按照顺序执行 方法①: 使用 Thread.join() 方法 */ public class ThereThread { public static void main(String[] args) { //创建第一个线程join1 final Thread join1 = new
三个线程T1,T2,T3.保证顺序执行的三种方法
chengyuan的博客
09-07 2089
线程
如何保证线程按照指定顺序执行
weixin_46591962的博客
03-15 381
思路 : 按照指定顺序执行，那么假如我有 abc 三个线程，要保证 b在a之后执行 c在b之后执行 ，那么按照这个思路，目前想到的java中提供了两种方式可以实现：1.使用Thread的join()方法 2.使用CountDownLatch类。
三个线程按顺序打印ABC？十二种做法，深入多线程同步通信机制
m0_63437643的博客
05-31 371
public static void printA() { //通过循环，hang住线程 while (state < 4) { try { //获取锁 lock.lock();
用java实现，三个线程实现打印ABC
07-27
可以使用Java中的多线程机制来实现三个线程按顺序打印ABC。以下是一种可能的实现方式： ```java public class PrintABC { private static final Object lock = new Object(); // 共享锁对象 private static volatile int state = 0; // 当前打印状态，0表示打印A，1表示打印B，2表示打印C public static void main(String[] args) { Thread threadA = new Thread(new PrintThread("A", 0)); Thread threadB = new Thread(new PrintThread("B", 1)); Thread threadC = new Thread(new PrintThread("C", 2)); threadA.start(); threadB.start(); threadC.start(); } static class PrintThread implements Runnable { private String name; private int targetState; public PrintThread(String name, int targetState) { this.name = name; this.targetState = targetState; } @Override public void run() { for (int i = 0; i < 10; i++) { // 打印10次 synchronized (lock) { while (state != targetState) { // 当前状态不是目标状态，等待 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.print(name); // 打印字符 state = (state + 1) % 3; // 更新状态 lock.notifyAll(); // 唤醒其他线程 } } } } } ``` 在上述代码中，我们创建了一个共享的锁对象 `lock` 和一个共享的状态变量 `state`。每个线程在运行时，都会先检查当前的状态是否为目标状态，如果不是则等待，直到状态匹配后打印对应的字符，并更新状态，然后唤醒其他线程。 通过 `Thread.currentThread().getName()` 可以获取当前线程的名字。 以上代码是一种简单的实现方式，但是由于多线程的执行是不确定的，所以打印的结果可能会交错。若要确保按照顺序打印ABC，可以使用信号量（Semaphore）等更高级的同步机制。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值