线程间通信知识总结_CPU

文章目录

为什么要进行线程间通信
线程间通信方式

休眠唤醒方式
CountDownLatch方式
CyclicBarrier方式
Semaphore方式
总结

多线程特性

为什么要进行线程间通信

多个线程并发执行时，在默认的情况下，CPU是随机切换线程的，而有时我们需要让CPU按照我们的期望来执行线程，此时就需要线程之间协调通信

线程间通信方式

1.休眠唤醒的方式，如：Object中的wait、notify、notifyAll和Condition中的await、signal、signalAll
2.CountDownLatch，用于某个线程A等待一个或多个其他线程执行完毕后，线程A才执行
3.CyclicBarrier,一组线程等待至某个状态后，再全部同时执行
4.Semaphore，用于控制对某组资源的访问权限

休眠唤醒方式

1.对于Object中的wait、notify方法使用的演示：

public class OddEven {
    private int i = 0;//要打印的数
    private Object o = new Object();
    /**
     * 打印奇数，由奇数线程来调用
     */
    public void odd() {
        while (i < 20) { //判断i是否小于20
            //判断是否是奇数
            synchronized (o) {
                if (i % 2 == 1) {
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                    o.notify();//唤醒偶数线程打印
                } else {
                    try {
                        o.wait(); //等待偶数线程打印完毕
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    /**
     * 打印偶数，由偶数线程来调用
     */
    public  void even() {
        while (i < 20) {
            synchronized (o) {
                if (i % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                    o.notify(); //唤醒奇数线程打印
                } else {
                    try {
                        o.wait(); //等待奇数线程打印
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        OddEven oddEven = new OddEven();
        Thread oddThread = new Thread(new Runnable() {
            @Override
            public void run() {
                oddEven.odd();
            }
        }, "奇数线程");

        Thread evenThread = new Thread(new Runnable() {
            @Override
            public void run() {
                oddEven.even();
            }
        }, "偶数线程");

        oddThread.start();
        evenThread.start();
    }
}

2.对于Condition中的await、signal方法使用的演示：

public class OddEven {
    private int i = 0;//要打印的数
    private Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    /**
     * 打印奇数，由奇数线程来调用
     */
    public void odd() {
        while (i < 20) { //判断i是否小于20
            //判断是否是奇数
            lock.lock();
            try {
                if (i % 2 == 1) {
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                    condition.signal();//唤醒偶数线程打印
                } else {
                    try {
                        condition.await(); //等待偶数线程打印完毕
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }

    /**
     * 打印偶数，由偶数线程来调用
     */
    public void even() {
        while (i < 20) {
            lock.lock();
            try {
                if (i % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                    condition.signal(); //唤醒奇数线程打印
                } else {
                    try {
                        condition.await(); //等待奇数线程打印
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        OddEven oddEven = new OddEven();
        Thread oddThread = new Thread(new Runnable() {
            @Override
            public void run() {
                oddEven.odd();
            }
        }, "奇数线程");
        Thread evenThread = new Thread(new Runnable() {
            @Override
            public void run() {
                oddEven.even();
            }
        }, "偶数线程");
        oddThread.start();
        evenThread.start();
    }
}

3.Object和Condition休眠唤醒使用总结：
①：object中的wait方法一定要配合synchronized（同步锁）使用
②：object中的wait方法需要用notify/notifyAll方法来唤醒
③：condition中的await方法一定要配合Lock（互斥锁/共享锁）来使用
④：condition中的await方法需要用signalAll方法来唤醒

CountDownLatch方式

CountDownLatch是在Java1.5中被引入的，存在于java.util.concurrent包下，通过一个计数器来实现，计数器的初始值为线程的数量，它能够使一个线程等待其他线程完成各自的工作后再执行。

关于CountDownLatch使用的代码演示：

/**
 * 学生教师模型
 * 教师需要等到所有学生都到齐并且准备就绪后才能开始教学任务
 */
public class CountDownLatchDemo {
    //设置要等待的学生为3个
    private CountDownLatch latch = new CountDownLatch(3);

    /**
     * 学生方法，由学生线程调用
     */
    public void student() {
        System.out.println(Thread.currentThread().getName() + "正在准备.......");
        try {
            //让线程睡眠1秒，表示学生的准备过程
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "准备就绪！");
        latch.countDown();
    }

    /**
     * 教师方法，由教师线程调用
     */
    public void teacher() {
        //1.获取教师线程名字
        String name = Thread.currentThread().getName();

        //2.教师线程等待所有的学生线程准备完毕，打印等待信息
        System.out.println(name+"正在等待......");

        //3.调用CountDownLatch的await方法等待学生线程
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //4.所有学生准备就绪，老师开始讲课
        System.out.println("所有学生已经到位，"+name+"可以开始讲课！");
    }

    public static void main(String[] args) {
        CountDownLatchDemo latchDemo = new CountDownLatchDemo();

        //创建3个学生线程，调用学生方法
        Thread s1 = new Thread(new Runnable() {
            @Override
            public void run() {
                latchDemo.student();
            }
        },"一号学生");
        Thread s2 = new Thread(new Runnable() {
            @Override
            public void run() {
                latchDemo.student();
            }
        },"二号学生");
        Thread s3 = new Thread(new Runnable() {
            @Override
            public void run() {
                latchDemo.student();
            }
        },"三号学生");

        //创建一个教师线程，调用教师方法
        Thread teacher = new Thread(new Runnable() {
            @Override
            public void run() {
                latchDemo.teacher();
            }
        },"老师");
        s1.start();
        s2.start();;
        s3.start();
        teacher.start();
    }
}

CyclicBarrier方式

CyclicBarrier是在java1.5中被引入的，存在于java.util.concurrent包下，其底层是基于ReentrantLock和Condition实现的，可以让一组线程等待至某个状态之后再全部执行。

关于CyclicBarrier使用的代码演示：

public class CyclicBarrierDemo {
    //构造方法中的参数表示参与CyclicBarrier的线程数
    private CyclicBarrier barrier = new CyclicBarrier(3);

    public void startThread(){
        //1.准备启动
        System.out.println(Thread.currentThread().getName()+"正在准备启动......");

        try {
            //2.调用Cyclicbarrier的await方法等待线程全部准备完成
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

        //3.启动完毕
        System.out.println(Thread.currentThread().getName()+"启动完毕  时间："+new Date().getTime());
    }

    public static void main(String[] args) {
        CyclicBarrierDemo barrierDemo = new CyclicBarrierDemo();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                barrierDemo.startThread();
            }
        },"线程1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                barrierDemo.startThread();
            }
        },"线程2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                barrierDemo.startThread();
            }
        },"线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}

Semaphore方式

Semaphore是在java1.5中被引入的，存在于java.util.concurrent包下，用于控制线程对某组资源的访问权限

关于对Semaphore使用的代码演示：

具体场景：一次春游中，一共有6个孩子，但是只有2条单人小船可以供孩子们玩耍（即每条小船只能乘坐一人）

public class SemophoreDemo {

    /**
     * 孩子使用小船进行玩耍的过程
     */
    static class Play implements Runnable {
        private int childNum;//孩子的编号
        private Semaphore semaphore;//小船数

        public Play(int childNum, Semaphore semaphore) {
            this.childNum = childNum;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                //1.孩子准备登上小船
                semaphore.acquire();

                //2.孩子已经登上小船，开始玩耍
                System.out.println(Thread.currentThread().getName() + "登上小船，开始玩耍......");

                //3.让线程睡眠1秒，模拟小孩坐在小船上玩耍的过程
                TimeUnit.SECONDS.sleep(1);

                //4.小孩玩够了，离开小船
                semaphore.release();
                System.out.println(Thread.currentThread().getName() + "玩够了，离开小船");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int children = 6;
        Semaphore semaphore = new Semaphore(2);
        for (int i = 0; i < children; i++) {
            new Thread(new Play(i,semaphore)).start();
        }
    }
}