关于java:线程间通信

34次阅读

共计 9540 个字符，预计需要花费 24 分钟才能阅读完成。

我是阿福，公众号 JavaClub 作者，一个在后端技术路上摸盘滚打的程序员，在进阶的路上，共勉！
文章已收录在 JavaSharing 中，蕴含 Java 技术文章，面试指南，资源分享。

把握的技术点如下：

  • 应用 wait/notify 实现线程间的通信
  • 线程的生命周期
  • 生产者 / 消费者模式的实现
  • 办法 join 的应用
  • ThreadLocal 类的应用

线程间通信

3.1 应用 wait/notify 实现线程间的通信

3.1.1 期待 / 告诉机制的实现

什么是期待 / 告诉机制

期待 / 告诉机制在咱们生存中亘古未有，比方在就餐时就会呈现，如下图所示：

  • 厨师做完一道菜的工夫不确定，所以厨师将菜品放到“菜品传递台”上的工夫也不确定。
  • 服务员取到菜的工夫取决于厨师，所以服务员就有“期待”（wait）的状态。
  • 厨师将菜放到“菜品传递台”上，其实就相当于一种告诉（notify）, 这是服务员能力拿到菜交给就餐者。

这个过程就呈现了“期待 / 告诉”机制。

应用专业术语讲：

期待 / 告诉机制，是指线程 A 调用了对象 O 的 wait()办法进入期待状态，而线程 B 调用了对象 O 的 notify()/notifyAll()办法，线程 A 收到告诉后退出期待队列，进入可运行状态，进而执行后续操作。上述两个线程通过对象 O 来实现交互，而对象上的 wait()办法和 notify()/notifyAll()办法的关系就如同开关信号一样，用来实现期待方和告诉方之间的交互工作。

期待 / 告诉机制的实现

wait()办法的作用：

是使以后线程进入阻塞状态，同时在调用 wait()办法之前线程必须取得该对象的对象级别锁，即 只能在同步办法或同步代码块中调用 wait()办法 。在执行 wait() 办法之后，以后线程 开释锁。

notify() notifyAll()办法的作用：

就是用来告诉那些期待该对象的对象锁的其余线程，如果有多个线程期待，则由线程布局器随机筛选其中一个呈 wait()状态的线程，对其发动告诉 notify, 并使它获取该对象的对象锁。

须要阐明的是 ：在执行 notify() 办法之后，以后线程不会马上开释该对象锁，呈 wait()状态的线程也不能马上获取该对象锁，要等到执行 notify()办法的线程将程序执行完，也就是退出 synchronized
代码块，以后线程才会开释锁，而呈 wait()状态所在的线程才能够获取对象锁。

强调 notify(),notifyAll()也是在同步办法或者是同步代码块中调用，即在调用之前必须取得该对象的对象级别锁。

用一句话总结一下 wait 和 notify: wait 使线程进行运行，而 notify 使进行的线程持续运行。

上面代码实现一个示例：

创立MyList.java, 代码如下：

public class MyList {private static List list=new ArrayList();
    public static void add(){list.add("anyString");
    }
    public static int size(){return list.size();
    }
}

自定义线程类 MyThread1.java, MyThread2.java，MyThread3.java代码如下：

public class MyThread1 extends Thread {
    private Object lock;

    public MyThread1(Object lock) {this.lock = lock;}

    @Override
    public void run() {
        try {synchronized (lock) {if (MyList.size() != 5) {System.out.println("开始 wait time=" + System.currentTimeMillis());
                    lock.wait();
                    System.out.println("完结 wait time=" + System.currentTimeMillis());
                }
            }
        } catch (InterruptedException e) {e.printStackTrace();
        }

    }
}

public class MyThread2 extends Thread {

    private Object lock;

    public MyThread2(Object lock) {this.lock = lock;}

    @Override
    public void run() {synchronized (lock) {for (int i = 0; i < 10; i++) {MyList.add();
                if (MyList.size() == 5) {lock.notify();
                    System.out.println("已发出通知");
                }
                System.out.println("增加了" + (i + 1) + "个元素！！");
            }
        }
    }
}

创立测试类 Test.java 

public class Test {public static void main(String[] args) {Object lock=new Object();
       MyThread1 myThread1=new MyThread1(lock);
       myThread1.start();
       MyThread2 myThread2=new MyThread2(lock);
       myThread2.start();}
}

程序代码运行后果如下：

开始 wait time=1618832467129
增加了 1 个元素！！
增加了 2 个元素！！
增加了 3 个元素！！
增加了 4 个元素！！
已发出通知
增加了 5 个元素！！
增加了 6 个元素！！
增加了 7 个元素！！
增加了 8 个元素！！
增加了 9 个元素！！
增加了 10 个元素！！
完结 wait time=1618832467130

从运行的后果来看，这也阐明 notify()办法执行后不是立刻开释锁。

3.2 线程的生命周期

线程生命周期转换图

线程的状态

线程从创立，运行到完结总是处于五种状态之一：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。

  • 新建状态：线程对象被创立后就进入了新建状态，Thread thread = new Thread();
  • 就绪状态 （Runnable）：也被称之为“可执行状态”，当线程被 new 进去后，其余的线程调用了该对象的 start() 办法，即 thread.start()，此时线程位于“可运行线程池”中，只期待获取 CPU 的使用权，随时能够被 CPU 调用。进入就绪状态的过程除 CPU 之外，其余运行所需的资源都曾经全副取得。
  • 运行状态（Running）：线程获取 CPU 权限开始执行。留神：线程只能从就绪状态进入到运行状态。
  • 阻塞状态（Bloacked）：阻塞状态是线程因为某种原因放弃 CPU 的使用权，临时进行运行，晓得线程进入就绪状态后能力有机会转到运行状态。

阻塞的状况分三种：

（1）、期待阻塞 ：运行的线程执行 wait() 办法，该线程会开释占用的所有资源，JVM 会把该线程放入“期待池中”。进入这个状态后是不能主动唤醒的，必须依附其余线程调用 notify()或者 notifyAll()办法能力被唤醒。
（2）、同步阻塞：运行的线程在获取对象的（synchronized）同步锁时，若该同步锁被其余线程占用，则 JVM 会吧该线程放入“锁池”中。

（3）、其余阻塞 ：通过调用线程的 sleep() 或者 join()或收回了 I / O 申请时，线程会进入到阻塞状态。当 sleep()状态超时、join()期待线程终止或者超时、或者 I / O 处理完毕时，线程从新回到就绪状态。

  • 死亡状态（Dead）：线程执行实现或者因异样退出 run 办法，该线程完结生命周期。

阻塞线程办法的阐明：

  • wait(), notify(),notifyAll()这三个办法是联合应用的，都属于 Object 中的办法，wait 的作用是使以后线程开释它所持有的锁进入期待状态（开释对象锁），而 notify 和 notifyAll 则是唤醒以后对象上的期待线程。
  • sleep() 和 yield()办法是属于 Thread 类中的 sleep()的作用是让以后线程休眠(正在执行的线程被动让出 CPU，而后 CPU 就能够去执行其余工作)，即以后线程会从“运行状态”进入到阻塞状态”，但依然放弃对象锁。当延时工夫过后该线程从新阻塞状态变成就绪状态，从而期待 CPU 的调度执行。
  • yield()的作用是退让，它可能让以后线程从运行状态进入到就绪状态”，从而让其余期待线程获取执行权，然而不能保障在以后线程调用 yield()之后，其余线程就肯定能取得执行权，也有可能是以后线程又回到“运行状态”持续运行。

wait ()，sleep()的区别：

1、sleep()睡眠时，放弃对象锁，依然占有该锁, 而 wait()开释对象锁.
2、wait 只能在同步办法和同步代码块外面应用，而 sleep 能够在任何中央应用。
3、sleep 必须捕捉异样，而 wait 不须要捕捉异样

3.3 生产者 / 消费者模式的实现

生产者消费者问题（Producer-consumer problem），也称无限缓冲问题（Bounded-buffer problem），是一个多线程同步问题的经典案例。生产者生成一定量的数据放到缓冲区中，而后反复此过程；与此同时，消费者也在缓冲区耗费这些数据。生产者和消费者之间必须放弃同步，要保障生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时耗费数据。不够欠缺的解决办法容易呈现死锁的状况，此时过程都在期待唤醒。

解决生产者 / 消费者问题的办法可分为两类

（1）采纳某种机制爱护生产者和消费者之间的同步；
（2）在生产者和消费者之间建设一个管道。第一种形式有较高的效率，并且易于实现，代码的可控制性较好，属于罕用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因而本文只介绍同步机制实现的生产者 / 消费者问题。

同步问题外围在于

如何保障同一资源被多个线程并发拜访时的完整性。罕用的同步办法是采纳信号或加锁机制，保障资源在任意时刻至少被一个线程拜访。Java 语言在多线程编程上实现了齐全对象化，提供了对同步机制的良好反对。在 Java 中一共有四种办法反对同步，其中前三个是同步办法，一个是管道办法。

（1）wait() / notify()办法

（2）await() / signal()办法

（3）BlockingQueue 阻塞队列办法

（4）PipedInputStream / PipedOutputStream

上面咱们通过 wait() / notify()办法实现生产者和消费者模式：

代码场景：

当缓冲区已满时，生产者线程进行执行，放弃锁，使本人处于等状态，让其余线程执行；
当缓冲区已空时，消费者线程进行执行，放弃锁，使本人处于等状态，让其余线程执行。

当生产者向缓冲区放入一个产品时，向其余期待的线程收回可执行的告诉，同时放弃锁，使本人处于期待状态；
当消费者从缓冲区取出一个产品时，向其余期待的线程收回可执行的告诉，同时放弃锁，使本人处于期待状态。

代码实现：

创立仓库Storage.java 代码：

public class Storage {
    // 仓库容量
    private final int MAX_SIZE = 10;
    // 仓库存储的载体
    private LinkedList<Object> list = new LinkedList<>();

    public void produce() {synchronized (list) {while (list.size() + 1 > MAX_SIZE) {System.out.println("【生产者" + Thread.currentThread().getName()
                        + "】仓库已满");
                try {list.wait();
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            list.add(new Object());
            System.out.println("【生产者" + Thread.currentThread().getName()
                    + "】生产一个产品，现库存" + list.size());
            list.notifyAll();}
    }

    public void consume() {synchronized (list) {while (list.size() == 0) {System.out.println("【消费者" + Thread.currentThread().getName()
                        + "】仓库为空");
                try {list.wait();
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            list.remove();
            System.out.println("【消费者" + Thread.currentThread().getName()
                    + "】生产一个产品，现库存" + list.size());
            list.notifyAll();}
    }

}

创立生产者线程Producer.java，消费者线程Consumer.java, 代码如下：

public class Producer implements Runnable {

    private Storage storage;

    public Producer(){}

    public Producer(Storage storage){this.storage = storage;}

    @Override
    public void run(){while(true){storage.produce();
        }
    }

}
public class Consumer implements Runnable{
    private Storage storage;

    public Consumer(){}

    public Consumer(Storage storage){this.storage = storage;}

    @Override
    public void run(){while(true){storage.consume();
        }
    }

}

创立测试类TestPc.java

public class TestPc {public static void main(String[] args) {Storage storage = new Storage();
        Thread p1 = new Thread(new Producer(storage));
        p1.setName("张三");
        p1.start();
        Thread c1=new Thread(new Consumer(storage));
        c1.start();
        c1.setName("李四");

    }


}

程序运行的局部后果：

【消费者李四】生产一个产品，现库存 8
【消费者李四】生产一个产品，现库存 7
【消费者李四】生产一个产品，现库存 6
【消费者李四】生产一个产品，现库存 5
【消费者李四】生产一个产品，现库存 4
【生产者张三】生产一个产品，现库存 5
【生产者张三】生产一个产品，现库存 6
【生产者张三】生产一个产品，现库存 7
【生产者张三】生产一个产品，现库存 8
【生产者张三】生产一个产品，现库存 9
【生产者张三】生产一个产品，现库存 10
【生产者张三】仓库已满
【消费者李四】生产一个产品，现库存 9
【消费者李四】生产一个产品，现库存 8
【消费者李四】生产一个产品，现库存 7

3.4 办法 join 的应用

在很多状况下，主线程创立并启动子线程，如果子线程中进行大量的运算，主线程往往早于子线程完结。这时主线程要期待子线程实现之后再完结。比方子线程解决一个数据，主线程要获得这个数据中的值，就要用到 join()办法。

join()办法就是期待线程对象销毁。

创立测试 MyJoinThread.java 代码：


public class MyJoinThread extends Thread{

    @Override
    public void run() {int secondValue= (int) (Math.random() * 10000);
        System.out.println(secondValue);
        try {Thread.sleep(secondValue);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}

创立测试类 TestJoin.java 代码：

public class TestJoin {public static void main(String[] args) throws InterruptedException {MyJoinThread myJoinThread=new MyJoinThread();
        myJoinThread.start();
        //myJoinThread.join();
        System.out.println("我想当 myJoinThread 对象执行结束我再执行，答案是不确定的");
    }
}

代码的运行后果：

我想当 myJoinThread 对象执行结束我再执行，答案是不确定的
9618

把 myJoinThread.join()代码正文去掉运行代码执行后果如下：

82
我想当 myJoinThread 对象执行结束我再执行，答案是不确定的

所以得出结论是：join()办法使所属线程对象 myJoinThread 失常执行 run()办法中的工作，而使以后线程 main 进行有限的阻塞，期待 myJoinThread 销毁完再继续执行 main 线程前面的代码。

办法 join()具备使线程排队运行的作用，有点相似同步运行的成果。

join()和 synchronized 的区别是：join()在外部应用 wait()办法进行期待，而 synchronized 关键字应用的是“对象监听器”的原理做的同步。

办法 join()与 sleep(long)的区别

办法 join(long)的性能在外部应用的是 wait(long)办法实现的，所用 join(long)办法具备开释锁的特点。

办法 join(long)源代码如下：

public final synchronized void join(long millis)
    throws InterruptedException {long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {while (isAlive()) {wait(0);
            }
        } else {while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {break;}
                wait(delay);
                now = System.currentTimeMillis() - base;}
        }
    }

从源代码中能够理解到，当执行 wait(long)办法后，以后线程的锁被开释，那么其余线程能够调用此线程中的同步办法了。

而 Thread.sleep(long)办法不开释锁。

3.5 ThreadLocal 类的应用

咱们晓得变量值的共享能够应用 public static 变量的模式，如果想实现每一个线程都有本人的共享变量该如何解决呢？JDK 中提供 ThreadLocal 正是解决这样的问题。

类 ThreadLocal 次要解决的就是为每个线程绑定本人的值，能够将 ThreadLocal 类比喻成全局存放数据的盒子，盒子中能够存储每一个线程的公有数据。

创立 run.java 类，代码如下：

public class run {private static  ThreadLocal threadLocal=new ThreadLocal();

    public static void main(String[] args) {if (threadLocal.get()==null){System.out.println("从未放过值");
           threadLocal.set("我的值");
       }
        System.out.println(Thread.currentThread().getName()+"线程:"+threadLocal.get());
    }
    

}

代码的运行后果：

从未放过值
main 线程: 我的值

从图中运行后果来看，第一次调用 threadLocal 对象的 get 办法返回为 null, 通过调用 set()赋值后值打印在管制台上，类 ThreadLocal 解决的是变量在不同线程间的隔离性，也就是不同的线程领有本人的值，不同线程的值能够寄存在 ThreadLocal 类中进行保留的。

验证线程变量的隔离性

创立 ThreadLocalTest 我的项目，类 Tools.java代码如下：

public class Tools {public static ThreadLocal local=new ThreadLocal();
}

创立线程类 MyThread1.java ,MyThread2.java代码如下：

public class MyThread1 extends Thread {

    @Override
    public void run() {for (int j = 0; j < 5; j++) {Tools.local.set(j+1);
            System.out.println(Thread.currentThread().getName()+"get value:"+Tools.local.get());
            try {Thread.sleep(200);
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
    }
}

public class MyThread2 extends Thread {


    @Override
    public void run() {for (int i = 0; i < 5; i++) {Tools.local.set(i+1);
            System.out.println(Thread.currentThread().getName()+"get value:"+Tools.local.get());
            try {Thread.sleep(200);
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
    }
}

创立 run.java 测试类

public class run {public static void main(String[] args) {MyThread1 myThread1=new MyThread1();
       myThread1.setName("myThread1 线程");
       myThread1.start();
       MyThread2 myThread2=new MyThread2();
       myThread2.setName("myThread2 线程");
       myThread2.start();}
}

程序运行后果：

myThread1 线程 get value:1
myThread2 线程 get value:1
myThread2 线程 get value:2
myThread1 线程 get value:2
myThread1 线程 get value:3
myThread2 线程 get value:3
myThread2 线程 get value:4
myThread1 线程 get value:4
myThread1 线程 get value:5
myThread2 线程 get value:5

尽管 2 个线程都向 local 中 set()数据值，但每个线程还是能取到本人的数据。

文章参考：

《Java 多线程编程核心技术》
https://blog.csdn.net/ldx1998…
https://blog.csdn.net/MONKEY_…

看到这里明天的分享就完结了，如果感觉这篇文章还不错，来个 分享、点赞、在看 三连吧，让更多的人也看到～

欢送关注集体公众号 「JavaClub」，定期为你分享一些技术干货。

正文完
java
发表至： java
2021-04-20
 0
关于java:SpringBoot核心④Web开发
关于java:说一个大家都知道的-Spring-Boot-小细节
不你不了解Spring实例化bean的时候做了什么
关于java:程序员过年大数据最怕问工资谈对象要见的姑娘比亲戚还多