线程间通信实例之轮流打印ABC

简介: 线程间通信实例之轮流打印ABC

线程间通信,就要联想到Object的wait、notify、notifyAll和Lock.new Condition()的await、signal、signalAll。

【1】需求一,三个线程顺序打印ABC,每个线程打印十次,ABC分别为线程名字

效果如下:

A
A
A
A
A
A
A
A
A
A
//BC依次排列

使用synchronized、wait、notifyAll实例代码如下:

public class TestSwapThread {
    public static void main(String[] args){
    //创建三把锁
        final Object obj1 = new Object();
        final Object obj2 = new Object();
        final Object obj3 = new Object();
        SwapThread swapThread = new SwapThread(obj1,obj2);
        SwapThread swapThread2 = new SwapThread(obj3,obj1);
        SwapThread swapThread3 = new SwapThread(obj2,obj3);
        swapThread.setName("A");
        swapThread.start();
        //这里来保证次序
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        swapThread2.setName("B");
        swapThread2.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread extends  Thread{
    private Object obj1 = null;
    private Object obj2 = null;
    public SwapThread(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    @Override
    public void run() {
        synchronized (obj1){
            System.out.println(Thread.currentThread().getName()+"准备进入第二层");
            synchronized (obj2){
                for (int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                }
         //nofityAll并不会释放锁,但是同步代码块执行完会自动释放锁
                obj2.notifyAll();
            }//这里释放内存锁
         //nofityAll并不会释放锁,但是同步代码块执行完会自动释放锁
            obj1.notifyAll();
            System.out.println(Thread.currentThread().getName()+" : end");
        }//这里释放外层锁
    }
}

使用lock实例如下

public class TestSwapThread3 {
    public static void main(String[] args){
      //这里也可作为swapThread3 构造参数传入
        //Lock lock = new ReentrantLock();
        SwapThread3 swapThread3 = new SwapThread3();
        new Thread(swapThread3,"A").start();
        new Thread(swapThread3,"B").start();
        new Thread(swapThread3,"C").start();
    }
}
class SwapThread3 implements Runnable{
  //共享数据--同一把锁 ReentrantLock
    private Lock lock =new ReentrantLock() ;
    @Override
    public void run() {
      //加锁
        lock.lock();
        try {
            int count =0;
            while (count<10){
                System.out.println(Thread.currentThread().getName()+" : "+count );
                count++;
            }
        }finally {
          //释放锁
            lock.unlock();
        }
    }
}

程序执行结果如下:

其实lock加锁/释放锁和顺序打印本质是保存线程执行的次序,严格意义从理论来讲,第二种方式在某些情况下是不太正确的。



【2】需求二,三个线程轮流打印ABC,每个线程打印十次,ABC分别为线程名字

效果如下:

A
B
C
//....

这时,就对线程通信要求高了。


使用synchronized、wait、notifyAll实例代码如下:

public class TestSwapThread4 {
    public static void main(String[] args){
        final Object obj1 = new Object();
        final Object obj2 = new Object();
        final Object obj3 = new Object();
        SwapThread4 swapThread = new SwapThread4(obj1,obj2);
        SwapThread4 swapThread2 = new SwapThread4(obj2,obj3);
        SwapThread4 swapThread3 = new SwapThread4(obj3,obj1);
        swapThread.setName("A");
        swapThread.start();
        swapThread2.setName("B");
        swapThread2.start();
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread4 extends  Thread{
    private Object obj1 = null;
    private Object obj2 = null;
    public SwapThread4(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            synchronized (obj1){
                synchronized (obj2){
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                    //notifyAll并不会释放锁,代码块结束后释放锁
                    obj2.notifyAll();
                }
                try {
                    //避免程序不能正常结束
                    if (i==9){
                        obj1.notifyAll();
                    }else{
                    //wait方法将会释放锁标志,进入阻塞状态,等到唤醒
                        obj1.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

测试结果如下:


使用Lock+Condition实例如下:

public class TestSwapThread2 {
    public static void main(String[] args){
        Lock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Condition conditionC = lock.newCondition();
        SwapThread2 swapThread = new SwapThread2(lock,conditionA,conditionB);
        SwapThread2 swapThread2 = new SwapThread2(lock,conditionB,conditionC);
        SwapThread2 swapThread3 = new SwapThread2(lock,conditionC,conditionA);
        swapThread.setName("A");
        swapThread.start();
        swapThread2.setName("B");
        swapThread2.start();
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread2 extends Thread{
    private Lock lock ;
    private Condition condition1;
    private Condition condition2 ;
    public SwapThread2(Lock lock,Condition condition1,Condition condition2){
        this.lock = lock;
        this.condition1=condition1;
        this.condition2=condition2;
    }
    @Override
    public void run() {
      //加锁
        lock.lock();
        try {
            int count =0;
            while (count<10){
            //唤醒等待condition2的线程
                condition2.signal();
                System.out.println(Thread.currentThread().getName()+" : "+count );
                count++;
                if (count==10){
                //避免程序不能结束
                    condition1.signalAll();
                }else{
                    try {
                      //当前线程进入阻塞,等到condition1被唤醒
                        condition1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }finally {
            lock.unlock();
        }
    }
}


目录
相关文章
|
30天前
|
存储 Java 数据库连接
java多线程之线程通信
java多线程之线程通信
|
30天前
|
Python
如何在Python中实现线程之间的同步和通信?
【2月更文挑战第17天】【2月更文挑战第51篇】如何在Python中实现线程之间的同步和通信?
|
30天前
|
Java
多线程实例练习题~
多线程实例练习题~
|
2天前
|
存储 安全 Java
Java并发基础-线程间通信
Java并发基础-线程间通信
5 0
|
14天前
|
安全 Java
Java的线程同步与通信:深入理解wait、notify和synchronized
Java的线程同步与通信:深入理解wait、notify和synchronized
14 0
|
15天前
|
Java 程序员
线程会很感谢你的,给它一个可以通信的传话筒
每个Java线程开始运行,按照你写的逻辑一步步的执行着,就像一个可怜的脚本,孤独地活着!只有它们内部的栈空间、程序计数器在陪伴着它们。 大家给可怜的单线程多加几个玩伴吗?创建一个多线程环境,给它们一个传话筒,让它们可以互相通信、互相问好、嬉皮打闹,看来单线程会很感谢你的。
7 0
线程会很感谢你的,给它一个可以通信的传话筒
|
23天前
|
Java 调度
【JAVA学习之路 | 提高篇】线程的通信
【JAVA学习之路 | 提高篇】线程的通信
|
27天前
|
Java
Java一分钟之-并发编程:线程间通信(Phaser, CyclicBarrier, Semaphore)
【5月更文挑战第19天】Java并发编程中,Phaser、CyclicBarrier和Semaphore是三种强大的同步工具。Phaser用于阶段性任务协调,支持动态注册;CyclicBarrier允许线程同步执行,适合循环任务;Semaphore控制资源访问线程数,常用于限流和资源池管理。了解其使用场景、常见问题及避免策略,结合代码示例,能有效提升并发程序效率。注意异常处理和资源管理,以防止并发问题。
41 2
|
30天前
|
存储 NoSQL Redis
深入浅出Redis(二):Redis单线程模型与通信流程
深入浅出Redis(二):Redis单线程模型与通信流程
|
30天前
线程间的通信
线程间的通信
16 0