两个线程交替输出问题

最新推荐文章于 2022-07-20 22:10:43 发布
最新推荐文章于 2022-07-20 22:10:43 发布
阅读量327 收藏 1
点赞数
分类专栏： 高并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44462054/article/details/120619814
版权

说明：本博客仅为个人学习笔记，无任何商业用途。

题目

建立两个线程循环输出两个数组中的内容。如A1B2C3D4E5…

LockSupport实现

public class LockSupportDemo {
    static Thread t1 = null;
    static Thread t2 = null;
    public static void main(String[] args) {

        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};

        Runnable r1 = ()->{
            for (char c : chars){
                System.out.print(c);
                LockSupport.unpark(t2);
                LockSupport.park();
            }
        };

        Runnable r2 = ()->{
            for (int c : arr){
                LockSupport.park();
                System.out.print(c);
                LockSupport.unpark(t1);
            }
        };

        t1 = new Thread(r1,"t1");
        t2 = new Thread(r2,"t2");

        t1.start();
        t2.start();
    }
}

synchronize实现

public class SynchronizedArr {
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                for (int c : arr) {
                    System.out.print(c);
                    lock.notify();
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //这个需要吗，为什么？
                lock.notify();
            }
        }, "t2").start();
        new Thread(() -> {
            synchronized (lock) {
                for (char c : chars) {
                    System.out.print(c);
                    lock.notify();
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }, "t1").start();
    }

}


public class SynchronizedArrState {
    final static Object lock = new Object();
    private static int state = 0;
    final static char [] chars = {'A','B','C','D','E'};
    final static int  [] arr = {1,2,3,4,5};
    static Thread t1 = null;
    static Thread t2 = null;


    public static void main(String[] args) {
        Runnable r1 = ()->{
          synchronized (lock){
              for(char c : chars){
                  while (state %2 != 0){
                      try {
                          lock.wait();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  System.out.print(c);
                  state++;
                  lock.notify();
              }
               //这个需要吗，为什么？
               lock.notify();
          }
        };
        Runnable r2 = ()->{
            synchronized (lock){
                for(int c : arr){
                    while (state %2 == 0){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.print(c);
                    state++;
                    lock.notify();
                }
            }
        };
        t1 = new Thread(r1,"t1");
        t2 = new Thread(r2,"t2");

        t2.start();
        t1.start();
    }
}

Lock实现

public class OneCondition {
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(()->{
            try{
                lock.lock();
                for (char c : chars) {
                    System.out.print(c);
                    condition.signal();
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                condition.signal();
            }finally {
                lock.unlock();
            }
        },"t1").start();

        new Thread(()->{
            try{
                lock.lock();
                for (int c : arr) {
                    System.out.print(c);
                    condition.signal();
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }finally {
                lock.unlock();
            }
        },"t2").start();

    }
}

public class TwoCondition {
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        ReentrantLock lock = new ReentrantLock();
        Condition ch = lock.newCondition();
        Condition in = lock.newCondition();

        new Thread(()->{
            try{
                lock.lock();
                for (char c : chars) {
                    System.out.print(c);
                    in.signal(); //唤醒数字线程
                    try {
                        ch.await(); //阻塞当前字符线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //必须需要 应为 t2 还在阻塞状态
                in.signal();
            }finally {
                lock.unlock();
            }
        },"t1").start();

        new Thread(()->{
            try{
                lock.lock();
                for (int c : arr) {
                    System.out.print(c);
                    ch.signal(); //唤醒字符线程
                    try {
                        in.await(); //阻塞当前数字线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }
}

semaphore实现

public class SemaphoreDemo {
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        Semaphore a1 = new Semaphore(1);
        //注意这里
        Semaphore a2 = new Semaphore(0);

        new Thread(()->{
            try {
                for (char c : chars){
                    a1.acquire(1);
                    System.out.print(c);
                    a2.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"t1").start();


        new Thread(()->{
            try {
                for (int c : arr){
                    a2.acquire(1);
                    System.out.print(c);
                    a1.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

CycliBarrier实现

public class CycliBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier c1 = new CyclicBarrier(2);
        CyclicBarrier c2 = new CyclicBarrier(2);
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        new Thread(()->{
            try {
                for (char c : chars){
                    //注意这里区别
                    System.out.print(c);
                    c1.await();
                    c2.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

        },"t1").start();


        new Thread(()->{
            try {
                for (int c : arr){
                    c1.await();
                    System.out.print(c);
                    c2.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

枚举+自旋

public class EnumSpin {
    enum Mlock{thread1,thread2}
    private static volatile Mlock flag = Mlock.thread1;
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};

        new Thread(()->{
            for (char c : chars){
                while(flag != Mlock.thread1){
                    //进行自旋
                }
                System.out.print(c);
                flag = Mlock.thread2;
            }
        },"t1").start();

        new Thread(()->{
            for (int c : arr){
                while(flag != Mlock.thread2){
                    //进行自旋
                }
                System.out.print(c);
                flag = Mlock.thread1;
            }
        },"t2").start();
    }

}

管道流

public class PipedStreamDemo {
    public static void main(String[] args) throws IOException {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};

        PipedInputStream input1 = new PipedInputStream();
        PipedInputStream input2 = new PipedInputStream();
        PipedOutputStream output1 = new PipedOutputStream();
        PipedOutputStream output2 = new PipedOutputStream();

        input1.connect(output2);
        input2.connect(output1);

        String turn = "you!";

        new Thread(()->{
            byte[] buffer = new byte[4];
            try {
                for(char c : chars){
                    input1.read(buffer);
                    if(new String(buffer).equals(turn)){
                        System.out.print(c);
                    }
                    output1.write(turn.getBytes());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            byte[] buffer = new byte[4];
            try {
                for(int c : arr){
                    System.out.print(c);
                    output2.write(turn.getBytes());
                    input2.read(buffer);
                    if(new String(buffer).equals(turn)){
                        continue;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        },"t1").start();
    }
}

TransferQueue

public class TransferQueueDemo {
    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        char[] arr = {'1', '2', '3', '4', '5'};

        TransferQueue<Character> queue = new LinkedTransferQueue<>();

        new Thread(()->{
            try {
                for(char c : chars){
                    System.out.print(queue.take());
                    queue.transfer(c);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            try {
                for(char c : arr){
                    queue.transfer(c);
                    System.out.print(queue.take());

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

BlockingQueue实现

take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

public class BlockingQueueDemo {
    static BlockingQueue<String> q1 = new ArrayBlockingQueue<>(1);
    static BlockingQueue<String> q2 = new ArrayBlockingQueue<>(1);

    public static void main(String[] args) {
        char[] chars = {'A', 'B', 'C', 'D', 'E'};
        int[] arr = {1, 2, 3, 4, 5};
        new Thread(()->{
            for (char c : chars){
                System.out.print(c);
                try{
                    q1.put("ok");
                    q2.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1").start();

        new Thread(()->{
            for (int c : arr){
                try{
                    q1.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.print(c);
                try{
                    q2.put("ok");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        },"t2").start();
    }

}

思考

1、这些方式那几种对线程的启动顺序没有要求？
2、synchronized中的两种方式差异是什么，为什么？
3、CycliBarrier实现中线程1可以改成下面的顺序吗？
___ 1)c1.await();
___ 2)System.out.print©;
____ 3)c2.await();
4、 枚举自旋中Mlock flag 需要volatile修饰吗？为什么

请评论区留言吧。

宫崎骏的杂货铺
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程交替输出问题3种常用解法（多线程经典面试题）
mischen520的博客
09-30 792
题目：让两个多线程交替输出 距离：“ABCDEF”和“123456”， 输出结果为固定“A1B2C3D4E5F6” 1.利用synchronized+wait/notify package com.mooc.house.user.controller; /** * @ClassName sync_wait_notify * @Description DOTO * @Author mischen * @Date 2021/9/30 0030 6:11 * @Version 1.0 **/ pub
线程交替输出（你能想出几种方法）
运气不好努力来凑
08-09 437
基础必会。LockSupport、ReentrantLock、wait和notify、LinkedTransferQueue。有空继续补充。
两个线程交替打印1A2B3C...
zhang_qing_yun的博客
07-03 781
java多线程 进程之间的通信
2个线程交替打印数据(多种方案)
weixin_44145478的博客
07-14 667
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
在Qt程序中如何优雅地实现线程切换
mjlong123123的专栏
03-03 2051
程序开发过程中，我们避免不了使用线程来执行耗时的操作，最常见的场景是启动线程执行耗时操作同时显示loading画面，当耗时操作完成时关闭loading界面。这样简单的操作中也涉及到了线程切换的动作。首先显示loading画面代码需要执行在ui线程，然后耗时操作执行在子线程。显示loading画面-》切换子线程-》执行耗时操作-》切换ui线程-》关闭loading画面。 Qt中有一个重要的概念是信号和槽，使用信号和槽我们可以实现消息数据的传递，当然这种传递也包括线程间的消息数据传递。槽指的是槽函数，槽函数运
Java 创建两个线程模拟对话并交替输出实现解析
08-25
Java 创建两个线程模拟对话并交替输出实现解析 本文主要介绍了 Java 中创建两个线程模拟对话并交替输出的实现解析。通过示例代码，详细地介绍了消费者和生产者的问题，展示了如何使用 Java 中的多线程技术来实现...
华为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();...
java 两个线程相互顺序输出
04-12
标题“java 两个线程相互顺序输出”涉及的问题是如何在多线程环境下控制线程的执行顺序，使得两个线程可以按照特定的顺序交替打印输出。这通常涉及到线程同步和通信的概念。下面将详细解释这些知识点。 1. **线程...
Java多线程实现同时输出
09-02
首先，来看一个简单的例子，这个例子涉及到两个线程，分别是线程A和线程B，它们的任务是交替打印字符A和B，形成"ABABABABA..."的效果。代码如下： ```java public class ThreadAB { public static void main...
线程练习题2
12-20
实现两个线程,一个线程打印1-52,另一个线程打印A-Z,要求输出的结果如下: 1 2 A 3 4 B 5 6 C 7 8 D 9 10 11 12 ... 52 E F G H I J K ... X Y Z 即：当数字小于9时，数字和字母交替打印； 当数字大于等于9时，先把...
两个线程循环打印A和B，例如线程A输出A，线程B输出B，一次按顺序循环输出ABABABABAB……
weixin_57107855的博客
07-20 647
220720
用信号量(互斥锁)实现两个线程交替打印
liqiao_418的博客
11-06 7329
本文实现两个线程交替打印，采用的是逐步添加代码，分析每一步代码的作用，若想要看最终版本可直接翻看后面的最终版本。（本文以信号量为例，互斥锁的实现只需将信号量的函数换成相应的互斥锁的函数，互斥锁（信号量）函数不知道的看https://blog.csdn.net/liqiao_418/article/details/83684347） 首先实现两个线程的打印，不加入信号量的应用，代码如下：（注：以下...
两个线程交替打印输出1-100
qq_21822741的博客
11-06 4351
思路：声明一个全局变量int i = 1；然后将这个变量锁定，线程轮流访问这个变量，并打印即可。   package thread; /** * @Title: ThreadTest1 * @Description: TODO * @Author: lz * @CreateDate: 2018/11/6 8:58 * @Version: 1.0 */ public class ...
linux两个线程交替执行,如何用C语言实现两个线程在Linux环境下打印1~100
weixin_28755331的博客
05-06 1377
怎么用C语言实现两个线程在Linux环境下打印1~100#include#include#include#includeintn=1;intN=100;pthread_mutex_tmutex;pthread_mutex_init(&mutex);void*func1(){while(n{pthread_mutex_lock(&mutex);printf(...
线程依次交替执行解决办法
feinifi的博客
06-29 1742
在面试题中，我们经常会遇到这样的题目，线程依次交替执行，比如有三个线程，第一个线程打印1-2-3,第二个线程接着打印4-5-6，第三个线程打印7-8-9，再更换到线程一运行打印10-11-12，依此类推。或者只有两个线程，他们直接交替执行。 我们知道，默认情况下，多线程运行，资源是共享的，也就是说他们是竞争关系，谁得到cpu资源，谁就运行，其他线程等待，当运行完毕，接下来由谁运行，是不确定的，有...
C# 两个线程轮流打印
q__y__L的博客
04-13 683
要想两个线程轮流打印，最常见的办法是加一个锁，每当该线程获取到锁后就打印，然后释放锁，让另一个线程打印，但锁也有它的局限性，比如，如果有四个线程，两两轮流使用，可能就需要2个锁，这不是一个好办法，这里介绍一个C#内置的工具：Semaphore，即信号量的意思。是操作系统原始提供的内核同步对象。 Semaphore semaphoreObject = new Semaphore(initialCount: 0, maximumCount: 5); 解释一下意思： 第一个参数为：initialCoun
两个线程，循环输出1~100
mycallchen的专栏
11-20 4887
public class Test {       //state==1表示线程1开始打印，state==2表示线程2开始打印       private static int state = 1;              private static int num1 = 1;       private static int num2 = 2;              pub
两个线程交替打印到多线程交替打印
jj89929665的博客
06-02 434
把Object类模板当做一把锁，两个线程去争夺这一把锁，最后的结果为预期中交替打印，但是这里会发现这里打断点可以看到，当打印最后的信息的时候进入了wait方法，使得当前线程等待，如果不最后唤醒对方，一定会使得有一个线程一直处于无限制的等待中。 我们以上面通用的思考方式去写下面的代码。 运行结果 发现有很多种可能性，答案是不确定的，最基本的输出就是两个数组总的全队列输出，在加第三个数组中的一个值输出，比如1a2b3c4d5e6f7gA。 最好的情况下就是全部输出但是程序不停，而且可能无法保证交替1A2B3
Java两个线程交替打印输出a1b2c3d4
哈库呐玛塔塔的博客
10-12 4260
1、线程1负责输出abcd public class Thread1 extends Thread { //定义锁对象，负责接收传入对象 private final Object lock; //定义共有构造方法 public Thread1(Object lock) { // TODO Auto-generated constructor stub this.lock = loc...
java两个线程交替执行
最新发布
05-07
在Java中，可以使用wait()和notify()方法实现两个线程交替执行。具体实现方法如下： 首先，定义一个共享的对象作为锁： ```java Object lock = new Object(); ``` 然后，定义两个线程类，分别为奇数线程和偶数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值