线程间定制化通信

曾经终败给现在 2022-09-11 01:19 159阅读 0赞

synchronized实现线程间通信的案例如果有多个线程那么就无法指定线程执行的顺序，我们可以使用Lock锁的Condition 实现线程定制化通信

# 实例： #

A线程打印2次A，B线程打印3次B，C线程打印5次C,按照此顺序循环10轮

思路：创建三个线程给每个线程设置一个标志位

线程A判断flag=0，打印2次，修改flag=1,通知线程B

线程B判断flag=1，打印3次，修改flag=2,通知线程C

线程C判断flag=2，打印5次，修改flag=0,通知线程A

package com.dongguo.concurrent.lock;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /** * @author Dongguo * @date 2021/9/3 0003-15:01 * @description: */
    public class ThreadOrderAccessDemo { 
        public static void main(String[] args) { 
            ShareResource shareResource = new ShareResource();
            new Thread(() -> { 
                for (int i = 1; i <= 10; i++) { 
                    shareResource.printA(i);
                }
            }, "A").start();
            new Thread(() -> { 
                for (int i = 1; i <= 10; i++) { 
                    shareResource.printB(i);
                }
            }, "B").start();
            new Thread(() -> { 
                for (int i = 1; i <= 10; i++) { 
                    shareResource.printC(i);
                }
            }, "C").start();
        }
    }
    
    class ShareResource { 
        private int flag = 0;
        private Lock lock = new ReentrantLock();
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();
        private Condition conditionC = lock.newCondition();
    
        public void printA(int i) { 
            try { 
                lock.lock();
                while (flag != 0) { 
                    conditionA.await();
                }
                System.out.println(Thread.currentThread().getName() + "输出,第" + i + "轮开始");
                //打印两次
                for (int j = 0; j < 2; j++) { 
                    System.out.println("A");
                }
                //唤醒B
                flag = 1;
                conditionB.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void printB(int i) { 
            try { 
                lock.lock();
                while (flag != 1) { 
                    conditionB.await();
                }
                System.out.println(Thread.currentThread().getName() + "输出,第" + i + "轮开始");
                //打印三次
                for (int j = 0; j < 3; j++) { 
                    System.out.println("B");
                }
                //唤醒C
                flag = 2;
                conditionC.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void printC(int i) { 
            try { 
                lock.lock();
                while (flag != 2) { 
                    conditionC.await();
                }
                System.out.println(Thread.currentThread().getName() + "输出,第" + i + "轮开始");
                //打印五次
                for (int j = 0; j < 5; j++) { 
                    System.out.println("C");
                }
                //唤醒A
                flag = 0;
                conditionA.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    }

运行结果：

A输出,第1轮开始
    A
    A
    B输出,第1轮开始
    B
    B
    B
    C输出,第1轮开始
    C
    C
    C
    C
    C
    A输出,第2轮开始
    A
    A
    B输出,第2轮开始
    B
    B
    B
    C输出,第2轮开始
    C
    C
    C
    C
    C
    A输出,第3轮开始
    A
    A
    B输出,第3轮开始
    B
    B
    B
    C输出,第3轮开始
    C
    C
    C
    C
    C
    A输出,第4轮开始
    A
    A
    B输出,第4轮开始
    B
    B
    B
    C输出,第4轮开始
    C
    C
    C
    C
    C
    A输出,第5轮开始
    A
    A
    B输出,第5轮开始
    B
    B
    B
    C输出,第5轮开始
    C
    C
    C
    C
    C
    A输出,第6轮开始
    A
    A
    B输出,第6轮开始
    B
    B
    B
    C输出,第6轮开始
    C
    C
    C
    C
    C
    A输出,第7轮开始
    A
    A
    B输出,第7轮开始
    B
    B
    B
    C输出,第7轮开始
    C
    C
    C
    C
    C
    A输出,第8轮开始
    A
    A
    B输出,第8轮开始
    B
    B
    B
    C输出,第8轮开始
    C
    C
    C
    C
    C
    A输出,第9轮开始
    A
    A
    B输出,第9轮开始
    B
    B
    B
    C输出,第9轮开始
    C
    C
    C
    C
    C
    A输出,第10轮开始
    A
    A
    B输出,第10轮开始
    B
    B
    B
    C输出,第10轮开始
    C
    C
    C
    C
    C