同时启动多个线程输出ABABAB或者ABCABCABC

最新推荐文章于 2023-11-02 19:19:33 发布
最新推荐文章于 2023-11-02 19:19:33 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WLQ0621/article/details/107430129
版权

目录

场景

线程A输出A，线程B输出B，同时启动线程A和线程B让其输出ABABAB……
线程A输出A，线程B输出B，线程C输出C，同时启动这三个线程让其输出ABCABCABC……


同时启动多个线程输出ABABAB

利用Object的wait()、notify()实现ABABAB……

这种方式的特点是，调用wait()、notify()之前必须使用synchronize绑定住被wait/notify的对象。所以，我们定义了一个单独的PrintAB类，在该类中实现打印A、打印B的方法，然后线程A、线程B引用PrintAB对象，调用对应的打印方法。

代码示例：

/**
 * 利用Object对象的wait()、notify()来实现
 *
 * @author wanglingqiang
 * @date 2020/7/18 下午3:28
 **/
public class PrintAB_Test1 {

    public static void main(String[] args) {
        PrintAB printAB = new PrintAB();
        
        new ThreadA(printAB).start();
        new ThreadB(printAB).start();
    }

    static class ThreadA extends Thread {
        private PrintAB printAB;

        public ThreadA(PrintAB printAB) {
            this.printAB = printAB;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                printAB.printA();
            }
        }
    }

    static class ThreadB extends Thread {
        private PrintAB printAB;

        public ThreadB(PrintAB printAB) {
            this.printAB = printAB;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                printAB.printB();
            }
        }
    }

    static class PrintAB {
        private boolean flag = true;

        public synchronized void printA() {
            while (!flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print("A");
            flag = false;
            this.notify();
        }

        public synchronized void printB() {
            while (flag) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.print("B ");
            flag = true;
            this.notify();
        }
    }
}

运行结果：

/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/bin/java
AB AB AB AB AB 
Process finished with exit code 0

PrintAB里打印A、打印B的方法，必须使用synchronize同步，否者会报异常：
java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)

在Object的notify()方法的JavaDoc中有相关的解释： A thread becomes the owner of the object’s monitor in one of three ways:

  1. By executing a synchronized instance method of that object.
  2. By executing the body of a synchronized statement that synchronizes on the object.
  3. For objects of type Class, by executing a synchronized static method of that class.

说白了，就是需要在调用wait()或者notify()之前，必须使用synchronized绑定住被wait/notify的对象。


利用Lock、Condition的await()、signal()实现ABABAB……

这种方式的实现特点是，打印不依赖第三方对象，每个线程自己实现打印的方法，方法里打印完唤醒对方、自己等待；把flag参数需要设置成全局静态的变量。
之所以可以去掉方式一定义PrintAB类，是因为Condition（配合Lock锁使用）能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个（因为不管是synchronize方法还是代码块对象代码块类Class，只能针对一个目标）。

/**
 * 利用Lock、Condition的await()、signal()实现
 * 每个线程自己实现打印的方法，打印不依赖第三方对象
 * flag参数需要设置成全局静态的变量
 *
 * @author wanglingqiang
 * @date 2020/7/18 下午3:53
 **/
public class PrintAB_Test2 {

    private static boolean flag;  //全局静态的变量

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();

        new ThreadA(lock, conditionA, conditionB).start();
        new ThreadB(lock, conditionA, conditionB).start();
    }

    static class ThreadA extends Thread {
        private Lock lock;
        private Condition conditionA;
        private Condition conditionB;

        public ThreadA(Lock lock, Condition conditionA, Condition conditionB){
            this.lock = lock;
            this.conditionA = conditionA;
            this.conditionB = conditionB;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 5; i++) {
                    if (flag) {
                        conditionA.await(); //a等待
                    }
                    System.out.print("A");
                    flag = true;
                    conditionB.signal();    //b唤醒
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    static class ThreadB extends Thread {
        private Lock lock;
        private Condition conditionA;
        private Condition conditionB;

        public ThreadB(Lock lock, Condition conditionA, Condition conditionB){
            this.lock = lock;
            this.conditionA = conditionA;
            this.conditionB = conditionB;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 5; i++) {
                    if (!flag) {
                        conditionB.await(); //b等待
                    }
                    System.out.print("B ");
                    flag = false;
                    conditionA.signal();    //a唤醒
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
}

运行结果：

/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/bin/java
AB AB AB AB AB 
Process finished with exit code 0

同时启动多个线程输出ABCABC

利用Object的wait()、notify()实现ABCABC……

线程A输出A，线程B输出B，线程C输出C，同时启动三个线程让其输出ABCABCABC……
true/false已不满足，我们通过%3取余来切换等待唤醒。

public class PrintAB_Test3 {
	private static int count = 0;  //全局静态的变量

    public static void main(String[] args) {
        PrintAB printAB = new PrintAB();

        new ThreadA(printAB).start();
        new ThreadB(printAB).start();
        new ThreadC(printAB).start();
    }

    static class ThreadA extends Thread {
        private PrintAB printAB;

        public ThreadA(PrintAB printAB) {
            this.printAB = printAB;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                printAB.printA();
            }
        }
    }

    static class ThreadB extends Thread {
        private PrintAB printAB;

        public ThreadB(PrintAB printAB) {
            this.printAB = printAB;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                printAB.printB();
            }
        }
    }

    static class ThreadC extends Thread {
        private PrintAB printAB;

        public ThreadC(PrintAB printAB) {
            this.printAB = printAB;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                printAB.printC();
            }
        }
    }

    static class PrintAB {

        public synchronized void printA() {
            try {
                while (count % 3 != 0) {
                    this.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print("A");
            count++;
            this.notifyAll();
        }

        public synchronized void printB() {
            try {
                while (count % 3 != 1) {
                    this.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print("B");
            count++;
            this.notifyAll();
        }

        public synchronized void printC() {
            try {
                while (count % 3 != 2) {
                    this.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print("C ");
            count++;
            this.notifyAll();
        }
    }
}

运行结果：

/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/bin/java
ABC ABC ABC ABC ABC 
Process finished with exit code 0

利用Lock、Condition的await()、signal()实现ABCABC……

线程A输出A，线程B输出B，线程C输出C，同时启动三个线程让其输出ABCABCABC……

这里还是使用方式二的Condition的await()、signal()实现，不同点在于3个线程比较切换，true/false已不满足，我们通过%3取余来切换等待唤醒。

/**
 * 利用Lock、Condition的await()、signal()实现
 * 每个线程自己实现打印的方法，打印不依赖第三方对象
 * count参数需要设置成全局静态的变量
 * 3个线程比较切换，方式二的true/false已不满足，我们通过%3取余来切换等待唤醒
 *
 * @author wanglingqiang
 * @date 2020/7/18 下午3:53
 */
public class PrintAB_Test4 {

    private static int count = 0;  //全局静态的变量

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Condition conditionC = lock.newCondition();

        new ThreadA(lock, conditionA, conditionB).start();
        new ThreadB(lock, conditionB, conditionC).start();
        new ThreadC(lock, conditionC, conditionA).start();
    }

    static class ThreadA extends Thread {
        private Lock lock;
        private Condition conditionA;
        private Condition conditionB;

        public ThreadA(Lock lock, Condition conditionA, Condition conditionB) {
            this.lock = lock;
            this.conditionA = conditionA;
            this.conditionB = conditionB;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 5; i++) {
                    while (count % 3 != 0) {//注意这里是不等于0，也就是说没轮到该线程执行，之前一直等待状态
                        conditionA.await(); //该线程A将会释放lock锁，构造成节点加入等待队列并进入等待状态
                    }
                    System.out.print("A");
                    count++;
                    conditionB.signal(); // A执行完唤醒B线程
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadB extends Thread {
        private Lock lock;
        private Condition conditionC;
        private Condition conditionB;

        public ThreadB(Lock lock, Condition conditionB, Condition conditionC) {
            this.lock = lock;
            this.conditionC = conditionC;
            this.conditionB = conditionB;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 5; i++) {
                    while (count % 3 != 1) {
                        conditionB.await();// B释放lock锁，当前面A线程执行后会通过B.signal()唤醒该线程
                    }
                    System.out.print("B");
                    count++;
                    conditionC.signal();// B执行完唤醒C线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class ThreadC extends Thread {
        private Lock lock;
        private Condition conditionC;
        private Condition conditionA;

        public ThreadC(Lock lock, Condition conditionC, Condition conditionA) {
            this.lock = lock;
            this.conditionC = conditionC;
            this.conditionA = conditionA;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                for (int i = 0; i < 5; i++) {
                    while (count % 3 != 2) {
                        conditionC.await();// C释放lock锁
                    }
                    System.out.print("C ");
                    count++;
                    conditionA.signal();// C执行完唤醒A线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

}

运行结果：

/Library/Java/JavaVirtualMachines/jdk1.8.0_241.jdk/Contents/Home/bin/java
ABC ABC ABC ABC ABC 
Process finished with exit code 0

至此，分享已结束。


pbxs
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
php分割合并两个字符串的函数实例
12-18
本文将详细探讨如何使用PHP函数来分割和合并两个字符串，以便创建特定的模式，如ABABAB。首先，我们来看一个名为`MergeBetween`的自定义函数，它能实现这个功能。 ```php function MergeBetween($str1, $str2) { /...
VBWebsocket.zip
03-17
一个用于VB6/VB.NET/C#的高性能Websocket客户端组件、支持WS、WSS协议，内含VB6/VB.NET/C#样本代码，稍微修改即可使用于产品，稳定可靠。完全采用C语言实现的Websocket组件，对Websocket协议完全实现。支持x64/x86两...
定义一个方法，同时启动两个线程，分别为A,B。其中A线程打印“a”，B线程打印“b”,要求按照ababab.... 的顺序交替打印输出。
最新发布
Yuan_Manman的博客
11-02 225
启动两个线程交替打印输出内容的三种实现方式。
Java多线程通信:交替打印ABAB实例
09-07
主要介绍了Java多线程通信:交替打印ABAB实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
多线程交替打印ABABAB
qq_37822034的博客
03-01 771
package testJunit; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; class Solution{ public static void main(String[] args) { Thread t1 = new Thread(new Threada()...
线程打印ABAB。使用两个线程
向高手学习
07-27 361
public class Solution{ public static void main(String[] args) { final ABAB2 abab2 = new ABAB2(); final ABAB2.Print p = abab2.new Print(); Thread a =new Thread(new Runnable() { public void run() { for(in.
两个线程交替打印AB
qq_42453201的博客
01-04 552
package github.write.funding2.mapper; /** * @Author: MaiYu * @Date: Create in 19:32 2020/12/12 */ public class Main3 { // public static void main(String[] args) { // String s=new String(); // System.out.println("3"); // } priv
多个线程同时运行，顺序打印问题
五山口老法师
03-27 906
输入一串字符串；开启三个线程；分别在输入的字符串后面打印 "_A" "_B" "_C" 输出结果。 输入：hello 输出：hello_A_B_C 思路：使用Callable 可以返回对应的打印，再在原字符串的基础上拼接。 1）使用join 2）使用线程池里的SingleThreadPool 第一种方法： import java.util.Scanner; impor...
大班数学教案：简单规律.doc
09-09
1. 观察与规律识别：活动通过图形的排列顺序，如○□○□○□，○□□○□□○□□，○□△○□△○□△，让孩子们学习识别和理解不同的排列模式（如ABABAB，ABBABBABB，以及ABCABCABC）。这有助于他们发展序列理解...
LeetCode每日一题(1) 字符串最大公因子
01-21
前言： 从今天开始每天一道leetcode，从简单的开始，加油！...输入：str1 = “ABABAB”, str2 = “ABAB” 输出：“AB” 输入：str1 = “LEET”, str2 = “CODE” 输出：”” 提示： 1 <= str1.le
java实现两个线程依此打印AB,java 实现3个线程 依次打印ABC，并且循环10次
weixin_29904391的博客
03-10 156
http://blog.csdn.net/pingnanlee/article/details/9468531package com.printabc; import java.util.concurrent.atomic.AtomicInteger; public class TestABC { /** * @param args */ public static void main...
两个线程,一个线程打印A,一个线程打印B,如何实现两个线程按顺序打印出ABABAB
qq_42230338的博客
10-06 1871
方法一：信号量 类似于生产者和消费者问题 #include <stdlib.h> #include <pthread.h> #include <stdio.h> #include <semaphore.h> sem_t blank_number, product_number; void *producer(void *arg) { wh...
Java小题目之两个线程顺序打印A、B
笨笨个人笔记
11-15 4720
1、问题描述使用Java多线程方式来实现循环打印A、B，并保证不乱序。2、解决方案java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。 利用synchronized关键字来实现 package org.ibenben.test;public class OrderThreadTest { public
两个线程交替打印ABABAB
dazhi_100的专栏
09-20 2682
一个简单的办法：定义一个全局变量flag 初始化为TRUE； 在线程a中判断flag是否为true 为true就打印 然后赋值为false 在线程b中判断flag是否为FALSE 为FALSE就打印 b 然后赋值为true
java双线程打印ABAB
hydhyd212的博客
12-26 573
main方法内，有两个实线程A和B，A线程只能打印“A”，B线程只能打印“B”，运行该方法后，打印结果为ABABABAB…，交替打印100次。利用join方法实现如下： public static void main(String[] args) throws InterruptedException{ } ...
linux进程同步之信号量
Ashley3082的博客
12-02 471
首先了解一下，信号量机概念是由荷兰科学家Dijkstr引入，值得一提的是，它提出的Dijksrtr算法解决了最短路径问题。 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源（如共享内存）的存取状况，信号量是一个特殊的变量，并且只有两个操作可以改变其值：等待(wait...
C#基础-多线程
热门推荐
jjailsa的博客
08-15 1万+
闲得蛋疼，整理一下C#线程的基础概念和常规用法。
Java多线程交叉打印ABABAB，一个线程打印A，一个线程打印B
江湖人称小程的博客
10-26 4929
在Java中想要完成此功能有好几种方法都可以实现，这篇文章主要使用 wait 和 notifyAll 方法。 具体需求为： 要求先打印字符 A ，再打印字符 B ，完了再打印字符 A …如此循环下去，要求格式为：ABABABABABAB… 原理： 首先需要两个线程，一个打印字符 A ，另一个打印字符 B ，那么如何让他们互相协作呢？此时，我需要一个 boolean 类型的变量 flag ，这个变量...
java多线程面试题：三个线程顺序打印ABC，重复10次
WaterTheGreat的博客
01-16 7561
这个面试题，比较经典。有不同的解决思路。有的博文是用Join去实现。我面试的时候也是第一个想到的是用join叫A线程等待B线程执行完再执行。这样的思路能实现，但是不好。虽然当时凑合着说服了面试官。先把代码贴出来 private Thread aThread,bThread,cThread; @Test public void test1() { aThread=new Thr
定义一个方法，同时启动两个线程，分别为A,B，其中A线程打印“a”，B线程打印“b”,要求按照ababab的顺序交替打印输出
03-29
```java public class ABThreadPrinter { public static void main(String[] args) { Object lock = new Object(); Thread a = new Thread(new PrintThread(lock, "a")); Thread b = new Thread(new PrintThread...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值