Java线程安全，线程间通信_java 线程安全通信-优快云博客

本文链接：https://blog.youkuaiyun.com/sinat_39119933/article/details/128460484

线程安全：如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题:
我们来模拟电影院的售票窗口，实现多个窗口同时卖“葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这10张票需要窗口，采用线程对象来模拟; 需要票，Runnable接口子类来模拟。

卖票代码如下：

package Ten;

import java.util.Random;

/**
 * 模拟简单的卖票程序
 */

public class Ticket implements Runnable{
        //定义资源变量，模拟卖票的总数
        //定义票的总数
        private int ticket=10;
        //定义一个同步资源
        Object lock=new Object();


        @Override
        public void run() {
            //获取当前程序执行所属的线程 的 名称
        String threadName=Thread.currentThread().getName();
        //2.一直卖票
        while (true) {
                if (ticket > 0) {
                    //卖第ticket张票
                    System.out.println(threadName + "正在售卖第" + ticket + "张票");
                    //模拟打印出票坏节，系统等待一会
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    //卖完了，总数-1
                    ticket--;

                } else {
                    break;//没票结束循环
                }
            }
        }
    }

public class ThreadTest01 {
    public static void main(String[] args) {
        //实例化卖票类的对象
        Ticket ticket=new Ticket();
        //把卖票对象作为参数创建线程，启动线程开始卖票（创建了小明这个线程，用来执行卖票程序）
        Thread t1=new Thread(ticket,"小明");
        Thread t2=new Thread(ticket,"小红");

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


    }

想象中的正常流程

运行结果：售卖了两张第10张票

正常卖票步骤应该当前线程的一个步骤执行完再去执行别的线程任务。但是CPU的执行机制是完全随机。有可能执行完第一步，跑到别的线程去执行。导致了征程操作流程下资源修改的错误问题。解决方案就是把三步骤同步一下，就是表示抢到了cpu执行权，cpu必须完整执行这三步后再能执行别的线程。

可能CPU的实际执行流程如图：

因此我们使用到了同步锁：

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制synchronized来解决。

synchronized关键字：

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

写法：

synchronized (锁对象) {

需要同步的代码（也就是可能出现问题的操作共享数据的多条语句）

}

同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁
1. 锁对象可以是任意类型。
2.多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着

代码如下：

public void run() {
        //获取当前程序执行所属的线程 的 名称
        String threadName = Thread.currentThread().getName();
        //2.一直卖票
        while (true) {
            //同步代码块 把大括号中的代码，使用资源锁同步起来(Cpu在执行该线程程序的时候，这段代码比完执行完才能离开)
            synchronized (lock) {
                if (ticket > 0) {
                    //卖第ticket张票
                    System.out.println(threadName + "正在售卖第" + ticket + "张票");
                    //模拟打印出票坏节，系统等待一会
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    //卖完了，总数-1
                    ticket--;

                } else {
                    break;//没票结束循环
                }
            }
        }
    }

运行结果如下：

简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

等待唤醒机制

概念:

多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同。

比如:线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

为什么要处理线程间通信：

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源:
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即——等待唤醒机制。

什么是等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race )，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。
就是在一个线程进行了规定操作后，就进入等待状态( wait（) )，等待其他线程执行完他们的指定代码过后再将其唤醒(notify（));在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程
wait/notify 就是线程间的一种协作机制。

如图：

等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下:
1.wait :线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知(notify() )"在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列( ready queue )中2. notify: 则选取所通知对象的 wait set 中的一个线程释放;例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
3.notifyAll: 则释放所通知对象的 wait set 上的全部线程。

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁( 很可能面临其它线程的竞争 )，成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下:

如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态。
否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态。

调用wait和notify方法需要注意的细节
1.wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

2. wait方法与notify方法是属于object类的方法的。因为:锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。

3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为: 必须要通过锁对象调用这2个方法

1.3 生产者与消费者问题

等待唤醒机制其实就是经典的"生产者与消费者”的问题。
就拿生产包子消费包子来说等待唤醒机制如何有效利用资源:

包子铺线程生产包子，吃货线程消费包子。当包子没有时( 包子状态为false )，吃货线程等待，包子铺线理生产包子( 即包子状态为true )，并通知吃货线程( 解除吃货的等待状,因为已经有包子了，那么包子铺线程进入等待态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完(包子状态为false )，并通知包子铺线程( 解除包子铺的等待状态）,吃货程进入等待。包子铺线程能否进一步执行则决于锁的获取情况

代码演示：

包子：

public class BaoZi {
    String name;  //包子名称
    boolean flag;//包子的状态 （true表示存在，false表示不存在）
}

吃货：

public class ChiHuo extends Thread{
    BaoZi baoZi;
    public ChiHuo(String name,BaoZi bz){
        super(name);
        this.baoZi=bz;
    }
    /**
     * 对于吃货----消费者
     * 如果包子不存在  进入等待状态
     * 如果包子 存在  进入执行状态，吃包子。  吃完之后包子变为不存在  此时唤醒早餐店制作包子
     */

    public void run(){
        String threadName=Thread.currentThread().getName();
        int count=0;
        while (true){
            synchronized (baoZi){
                count++;
                if (count>10){
                    break;
                }
                if(baoZi.flag){ //如果包子存在
                    System.out.println(threadName+"开始吃"+baoZi.name);
                    baoZi.flag=false; //修改状态
                    baoZi.notify();  //唤醒同一资源下的其他线程
                }else {  //如果包子不存在
                    try{
                        baoZi.wait(); //进入等待状态
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }

        }
    }

}

包子铺类：

package Eleven;

public class Zaocandian extends Thread{

    BaoZi baoZi;
    //构造方法：用来指定线程的名字和要操作的资源
    public Zaocandian(String name,BaoZi bz){
        super(name);
        this.baoZi=bz;
    }

    /**
     * 对于早餐店---生产者
     *  如果包子  不存在  进入执行状态，制造包子。制作完毕包子存在，唤醒吃货
     *  如果包子   存在   进入等待状态
     */

    @Override
    public void run(){
        //获取当前线程的名称
        String threadName=Thread.currentThread().getName();
        int count=0;
        while (true){
            synchronized (baoZi){
                count++;
                if(count>10){
                    break;
                }
                if(baoZi.flag){    //如果包子存在
                    try {
                        baoZi.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }else {  //如果包子不存在
                    System.out.println(threadName+"开始制作"+baoZi.name); //制作包子
                    baoZi.flag=true;//更改包子状态
                    baoZi.notify();//唤醒同一资源下的其他线程
                }
            }
        }
    }
}

测试代码：

public class ThreadTest01 {
    public static void main(String[] args) {
        //定义资源对象
        BaoZi baoZi=new BaoZi();
        baoZi.name="韭菜鸡蛋";
        baoZi.flag=true;

        //定义两个线程，起名字且操作同一个对象
        ChiHuo ch=new ChiHuo("猪八戒",baoZi);
        Zaocandian zcd=new Zaocandian("春光早餐",baoZi);

        zcd.start();
        ch.start();
    }
}

运行结果：