JAVA中实现两个线程的交替打印

已于 2023-11-08 10:22:49 修改
阅读量205 收藏
点赞数
文章标签： java 开发语言
于 2023-11-07 10:06:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46541030/article/details/134259456
版权

方式1：CAS + 自旋

通过自旋切换打印

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // CAS自旋打印方式
        casRollPrint();
    }

    /**
     * CAS自旋打印方式
     */
    private static void casRollPrint() {
        // atomic 原子类
        AtomicBoolean flag = new AtomicBoolean(true);

        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                // 自旋等待
                while (flag.get()) {
                    System.out.print("A");
                    // 步进 + 切换flag
                    i++;
                    flag.set(false);
                }
                // 让出CPU
                Thread.yield();
                // 依赖自旋 此处增加打印语句 可以证明
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                // 自旋等待
                while (!flag.get()) {
                    System.out.print("B");
                    // 步进 + 切换flag
                    i++;
                    flag.set(true);
                }
                // 让出CPU
                Thread.yield();
            }
        }).start();
    }
}

方式2：volatile + 自旋

通过自旋切换打印

public class ThreadAlternatePrint {

    // volatile 保证内存可见性
    private static volatile boolean flag;

    public static void main(String[] args) {
        volatileCtlPrint();
    }


    private static void volatileCtlPrint() {
        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                // 自旋等待
                while (!flag) {
                    System.out.print("A");
                    i++;
                    flag = true;
                }
                Thread.yield();
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                // 自旋等待
                while (flag) {
                    System.out.print("B");
                    i++;
                    flag = false;
                }
                Thread.yield();
            }
        }).start();
    }
}

方式3：synchronized + 对象锁

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // synchronized打印方式
        syncKeywordRollPrint();
    }


    private static void syncKeywordRollPrint() {
        Object lock = new Object();
        AtomicBoolean mark = new AtomicBoolean(false);

        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                synchronized (lock) {
                    while (mark.get()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    System.out.print("A");
                    i++;
                    mark.set(true);
                    lock.notifyAll();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; ) {
                synchronized (lock) {
                    while (!mark.get()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    System.out.print("B");
                    i++;
                    mark.set(false);
                    lock.notifyAll();
                }
            }
        }).start();
    }
}
public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // synchronized打印方式
        syncKeywordRollPrint();
    }


    private static void syncKeywordRollPrint() {
        Object lock = new Object();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    System.out.print("A");
                    lock.notifyAll();
                    try {
                        if (i == 9) {
                            return;
                        }
                        lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    System.out.print("B");
                    lock.notifyAll();
                    try {
                        if (i == 9) {
                            return;
                        }
                        lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }).start();
    }
}

方式4：ReentrantLock + Condition

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // ReentrantLock打印方式
        reentrantLockRollPrint();
    }

    private static void reentrantLockRollPrint() {
        ReentrantLock lock = new ReentrantLock(true);
        Condition condition = lock.newCondition();
        // 配合原子mark 不然不能保证强一致顺序
        AtomicBoolean mark = new AtomicBoolean(false);
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (mark.get()) {
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    System.out.print("A");
                    mark.set(true);
                    condition.signalAll();
                } finally {
                    lock.unlock();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (!mark.get()) {
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    System.out.print("B");
                    mark.set(false);
                    condition.signalAll();
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

方式5：BlockingQueue

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // blockQueue打印方式
        blockQueueRollPrint();
    }

    private static void blockQueueRollPrint() {
        BlockingQueue<Integer> bqA = new LinkedBlockingQueue<>(1), bqB = new LinkedBlockingQueue<>(1);

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    bqA.put(i);
                    System.out.print("A");
                    bqB.put(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    bqB.take();
                    System.out.print("B");
                    bqA.take();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
}

方式6：CyclicBarrier

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // CyclicBarrier打印方式
        cyclicBarrierRollPrint();
    }

    private static void cyclicBarrierRollPrint() {
        CyclicBarrier cb = new CyclicBarrier(2);
        AtomicBoolean mark = new AtomicBoolean(false);

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                while (mark.get()) {
                }
                System.out.print("A");
                mark.set(true);
                try {
                    cb.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                while (!mark.get()) {
                }
                System.out.print("B");
                mark.set(false);
                try {
                    cb.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
}

方式7：LockSupport

public class ThreadAlternatePrint {

    static Thread th1 = null, th2 = null;

    // main方法
    public static void main(String[] args) {
        // LockSupport打印方式
        lockSupportRollPrint();
    }


    private static void lockSupportRollPrint() {
        th1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print("A");
                LockSupport.unpark(th2);
                LockSupport.park();
            }
        });

        th2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(th1);
            }
        });

        th1.start();
        th2.start();
    }
}

方式8：信号量

public class ThreadAlternatePrint {

    // main方法
    public static void main(String[] args) {
        // Semaphore打印方式
        semaphoreRollPrint();
    }

    private static void semaphoreRollPrint() {
        Semaphore spA = new Semaphore(1), spB = new Semaphore(0);

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    spA.acquire();
                    System.out.print("A");
                    spB.release();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    spB.acquire();
                    System.out.print("B");
                    spA.release();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
}

彧铂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java实现两个线程交替打印的实例代码
08-25
在本篇文章里小编给大家整理的是一篇关于java实现两个线程交替打印的相关知识点内容，有需要的朋友们参考下。
java实现两个线程交替打印
sinat_41878445的博客
05-26 2896
有{1,2,3,4,5,6,7,8,9,10}和{10,20,30,40,50,60,70,80,90,100}两个数组，我们要实现的是分别打印1、2、10、20、3、4、30、40… 接下来我们将使用volatile和wait()、notify()两种方法来实现两个线程的交替打印。 一.使用volatile public class UseVolatile { static volatile boolean flag; public static void main(String[] a
两个线程交替打印
qq_46153765的博客
12-18 1812
题目：起两个线程交替打印0~100的奇偶数 这个问题大家可能在面试的时候遇到过，虽然学过多线程相关的知识，可能当时一时半会还写不出来，现在就让我带大家写一遍吧！ 方法一 首先，我们可以观察到打印的是奇数和偶数，那么我们就可以通过这个特点去写代码。假如我们有一个全局变量 count，当 count 等于偶数的时候，我们就让线程1打印，当 count 等于奇数的时候，我们就让线程2打印。那如何实现呢？这里我们就可以用到锁了，来保证同一时刻只有一个线程在执行。但是如果同一个线程一直抢到锁，而另一个线程一直没有拿到
2个线程交替打印
lijun0988的专栏
09-14 361
public void testAB() {         final Lock3 lock = new Lock3();         Thread a = new Thread() {             public void run() {                     for (int i=1;i100;i++) {
Java 创建两个线程模拟对话并交替输出实现解析
08-25
主要介绍了Java 创建两个线程模拟对话并交替输出实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java基础教程301集287 两个线程交替打印.mp4
05-20
java基础教程301集287 两个线程交替打印.mp4
华为Java高级面试题:用两个线程,一个输出字母,一个输出数字,交替输出1A2B3C4D…26Z
01-20
HSDIS查看Java代码的汇编指令 java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssemble 使用 LockSupport.park()and unpark() public static void main(String[] args) { char[] aI = 1234567.toCharArray(); ...
多线程 打印1-99,100-199
10-17
1. 实现一个类ThreadMock（模拟线程），用来模仿Thread类，该类具有以下特征： ... 两个线程交替打印。例如第一个线程打印1，接着第二个线程打印100，接着第一个线程打印2。。。。。。。。依此类推。
多线程：使用两个线程交替打印数字和字母
95年的巨蟹
04-03 3644
题目 使用两个线程,一个打印数字，一个打印字母;交替打印，实现打印 1A2B3C4D; 1.思路说明： 1.1 要想实现双线程交替打印，首先得创建两个线程；使用实现runable接口方式创建两个线程；重写run方法，执行打印； 1.2 两个线程交替打印，是一种同步思想，需要让两个线程持有同一把锁（交替持有）,可以利用synchronized修饰普通方法（相当于锁this对象，实现了两个线程同一把锁）； 1.3 两个线程交替持有锁，持有锁的那个进行打印；没有锁的那个的等待；可以定义布尔类型变量控制实现反转；
java如何优雅的实现多线程交替打印？
Chain的博客
12-12 878
前几天有人问我交替打印如何实现，在面试过程中出现的大部分都是两个线程交替打印1-100内的数字，那么有没有一个通用的模板，适用于多个线程以及打印任意范围的数呢，今天发一下我写的模板，大家有什么建议可以回复，我再进行修改。 package com.java.alibaba.yimian; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.ut
两个线程交替打印1-100
热门推荐
一路的博客
05-08 1万+
线程之间的通信基本的三个方法： wait():一旦执行该方法，当前线程就会堵塞状态，并释放同步监视器（锁） notify():一旦执行该方法，就会唤醒被wait的一个线程，如果是多个，则唤醒优先级高的线程 notifyAll():一旦执行该方法，就会唤醒所有被wait的线程 使用 synchronized 和 wait notify 来实现两个线程交替打印： public class TestPrintNumber { public static void main(String[] args)
2个线程交替打印数据(多种方案)
weixin_44145478的博客
07-14 652
public class PrinterAB { private final Object monitor = new Object(); private int limit; private PrinterAB(int limit) { this.limit = limit; } private void sycFoo() { for (int i = 0; i < limit; i++) { sy
每日一问 - 两个线程交替打印 ABABAB
面朝大海，春暖花开
09-24 1290
每日一问 - 两个线程交替打印 ABABAB… 问题 两个线程交替打印 ABABAB... ? 两个线程交替打印 ABABAB 打印 10 次？ 解决方案 考的就是线程之间通信问题， 使用　wait, notify 交替打印AB public class ABCoreHolder { private boolean flag = true; public void printA() throws Exception { synchronized (this) {
两个线程交替打印字母 java
yuchen_2012的专栏
09-10 1010
package com.example.socket; public class test {         private static Object LOCK = new Object();       private static boolean flag = false;            class A extends Thread{         publ
多线程面试题-两个线程交替打印
weixin_39937764的博客
07-25 167
参考博客：https://blog.csdn.net/afsvsv/article/details/86521789 通用字段，注意volatile的使用，保证可见性 public static int i = 1; public volatile static int j = 1; public volatile static boolean flag = false; public static int count = 0; public static Lock lock = new Reen
java两个线程交替打印0~100
qq_38765865的博客
08-04 473
1、（不推荐）单单使用synchronized锁代码块，会出现同一个线程一直抢到锁，而另一个线程一直没有拿到，就会导致线程做很多无谓的空转。 private int count = 0; private final Object lock = new Object(); public void turning() { Thread even = new Thread(() -> { while (count < 100) { sync
java两个线程交替执行
最新发布
05-07
在Java中，可以使用wait()和notify()方法实现两个线程交替执行。具体实现方法如下： 首先，定义一个共享的对象作为锁： ```java Object lock = new Object(); ``` 然后，定义两个线程类，分别为奇数线程和偶数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值