下面模拟不使用wait/notify机制进行通信,然后分析其缺点所在
public class multithreadingtest {
static volatile private List list=new ArrayList() ; //TODO 使用volatile修饰,可以实现线程之间数据的可见性
public static void main(String[] args) {
Thread thread1=new Thread(new Runnable() { //TODO 线程thread1实现循环向list中添加元素
@Override
public void run() {
int i=1;
while(i>0)
{
list.add(i); //TODO 向集合中添加元素
System.out.println("添加了"+i+"个元素");
i++;
try {
Thread.sleep(1000); //TODO 这里睡眠是为了等待Thread2执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread thread2=new Thread(new Runnable() { //TODO 线程thread2判读集合中元素中的数量是否达到了5
@Override
public void run() {
try {
while(true)
{
if(list.size()==5){
System.out.println("thread2要退出了");
throw new InterruptedException(); //TODO 以抛出异常的方式结束线程
}
}
}catch (InterruptedException e)
{
e.printStackTrace();
}
}
});
thread1.setName("thread1");
thread2.setName("thread2"); //TODO 设置进程名
thread1.start();
thread2.start();
}
}
分析代码,这里的线程间通信是指,thread1向集合中添加的数据达到5个后,通知线程2结束。虽然两个线程以集合为媒介完成了通信,但还存在缺点,thread2需要使用while循环不断轮询检测某一个条件,这样会很浪费CPU资源,所以需要引入一种机制,在减少CPU资源浪费的同时,还可以实现在多个线程之间的通信,这就是wait/notify机制。
wait/notify机制是Java中用于线程间通信的一种机制。它基于“监视器对象”(monitor object)的概念,通过在多个线程之间共享一个对象锁来实现线程的协作。在wait/notify机制中,线程可以调用对象的wait()方法来阻塞自己,直到其他线程调用同一个对象的notify()或notifyAll()方法来唤醒它。当一个线程调用wait()方法时,它会释放对象的锁,使其他线程能够获取该对象的锁并执行相应的操作。当其他线程调用notify()或notifyAll()方法时,它们会唤醒等待在该对象上的线程,使它们重新竞争对象的锁,继续执行操作。使用wait/notify机制可以实现一些复杂的线程协作模式,比如生产者消费者模式、读写锁模式等。但是在使用过程中需要特别注意避免死锁、竞态条件等问题。
注意:拥有相同锁的线程才可以实现wait/notify机制。
wait()方法
wait()Object类的方法,它的作用是使当前执行该方法的进程进行等待,在wait()所在的代码处暂停执行,并释放锁
IllegalMonitorStateException
notify()方法
该方法用于唤醒当前正在wait的线程,对线程的选择是按wait方法的顺序确定的
IllegalMonitorStateException
wait()方法使当前线程暂停运行,并释放锁
public static void main(String[] args) throws InterruptedException {
String name=new String();
name.wait();
}
public static void main(String[] args) throws InterruptedException {
String name=new String();
synchronized (name)
{
System.out.println("wait前");
name.wait();
System.out.println("wait后");
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread1=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("thread1跑起来了");
try {
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("thread1跑完了");
}
}
});
Thread thread2=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list)
{
System.out.println("thread2跑起来了");
list.notify();
System.out.println("thread2跑完了");
}
}
});
thread1.start();
Thread.sleep(3000);
thread2.start();
}
除了notify()方法外还有一个notifyAll()方法,该方法执行后会按照执行wait()方法的倒序依次唤醒“全部”的线程
Sleep()方法和wait()方法一样也会让线程陷入阻塞,但sleep并不会让持有锁的线程释放锁,而锁陷入等待(这是一种同步效果)
当线程调用wait()方法后,再对该线程对象执行interrupt()方法时,会出现InterruptedException
异常
public static void main(String[] args) throws InterruptedException {
Thread thread1=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("thread1跑起来了");
try {
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("thread1跑完了");
}
}
});
thread1.start();
thread1.interrupt();
}
每次调用notify方法,只通知一个线程进行唤醒,唤醒的顺序按执行wait()方法的正序。
public static void main(String[] args) throws InterruptedException {
Thread thread1=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("第一个wait");
try {
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
list.notify();
System.out.println("第一个结束");
}
}
});
Thread thread2=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("第二个wait");
try {
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
list.notify();
System.out.println("第二个结束");
}
}
});
Thread thread3=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("第三个wait");
try {
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
list.notify();
System.out.println("第三个结束");
}
}
});
Thread thread4=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list)
{
System.out.println("开始通知");
list.notify();
System.out.println("通知结束");
}
}
});
thread1.start();
thread2.start();
thread3.start();
Thread.sleep(3000);
thread4.start();
}
总结
nofity一次调用只能唤醒一个线程,所以容易出现部分线程对象没有被唤醒的情况。为了唤醒全部线程,可以使用notifyAll方法,它会按照执行wait方法的倒序一次对线程进行唤醒的。
带有一个参数的wait(long)方法的功能是等待某一个时间内是否有线程进行通知唤醒,如果超过这个时间则自动唤醒。能继续向下运行的前提是再次持有锁。(注意也是可以在long时间内被其它线程唤醒的)
public static void main(String[] args) throws InterruptedException {
Thread thread1=new Thread(new Runnable() {
@Override
public void run() {
synchronized (list) {
System.out.println("开始时间:"+System.currentTimeMillis());
try {
list.wait(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("开始时间:"+System.currentTimeMillis());
}
}
});
thread1.start();
}
生产者/消费者模式:在一个系统中,存在生产者和消费者两种角色,他们通过内存缓冲区进行通信,生产者生产消费者需要的资料,消费者把资料做成产品。wait/notify机制最经典的案例“生产者与消费者模式”模式。
案例一:单生产者和单消费者模式
一个生产者生产,一个消费者消费,没有产品时生产者才能生产,有产品时消费者才能消费
//消费者
public class P {
private String lock;
public P(String lock){
super();
this.lock=lock;
}
public void GetValue(){
try{
synchronized (lock){
if(ValueObject.value.equals("")){ //value不为空说明消费者还没有消费,所以生产者需要等待
lock.wait();
}
System.out.println("我现在要开始消费了!");
lock.notify();
System.out.println("消费的产品:"+ValueObject.value);
ValueObject.value="";
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//生产者
public class C {
private String lock;
public C(String lock){
super();
this.lock=lock;
}
public void SetValue(){
try{
synchronized (lock){
if(!ValueObject.value.equals("")){ //value不为空说明消费者还没有消费,所以生产者需要等待
lock.wait();
}
System.out.println("我现在要开始生产了!");
lock.notify();
String value= String.valueOf(System.currentTimeMillis())+"_"+String.valueOf(System.nanoTime());
System.out.println("生产的产品:"+value);
ValueObject.value=value;
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//消费者线程
public class ThreadB extends Thread{
private P p;
public ThreadB(P p){
super();
this.p=p;
}
@Override
public void run(){
while(true){ //消费者消费
p.GetValue();
}
}
}
//生产者线程
public class ThreadA extends Thread{
private C c;
public ThreadA(C c){
super();
this.c=c;
}
@Override
public void run(){
while(true){ //生产者不断生产
c.GetValue();
}
}
}
//main函数
public static void main(String[] args) {
String lock=new String("");
P p=new P(lock);
C c=new C(lock);
ThreadA threadA=new ThreadA(p);
ThreadB threadB=new ThreadB(c);
threadA.start();
threadB.start();
}
在上面案例代码的基础上,多增加生产者,使得生产者的数据远远大于消费者,会出现连续生产的问题,导致生产的内容会发生覆盖,而消费者的数量远远大于生产者的数量时,会发生消费者消费空值的情况。原因是if条件发生改变时,其它的线程并不知道。同时还会出现唤醒同类的情况,最终出现连续生产或连续消费,导致程序的逻辑出现错误。解决这个问题的方法就是把if判断改为while判断。
写覆盖代码
public class multithreadingtest {
public static void main(String[] args) {
String lock=new String("");
P p=new P(lock);
C c=new C(lock);
ThreadA[] pThread=new ThreadA[20];
ThreadB[] rThread=new ThreadB[20];
for (int i = 0; i < 20; i++) {
pThread[i]=new ThreadA(c);
pThread[i].setName("生产者"+(i+1));
pThread[i].start();
}
for (int i = 0; i < 2; i++) {
rThread[i]=new ThreadB(p);
rThread[i].setName("消费者"+(i+1));
rThread[i].start();
}
}
}
消费空值代码
public class multithreadingtest {
public static void main(String[] args) {
String lock=new String("");
P p=new P(lock);
C c=new C(lock);
ThreadA[] pThread=new ThreadA[20];
ThreadB[] rThread=new ThreadB[20];
for (int i = 0; i < 2; i++) {
pThread[i]=new ThreadA(c);
pThread[i].setName("生产者"+(i+1));
pThread[i].start();
}
for (int i = 0; i < 20; i++) {
rThread[i]=new ThreadB(p);
rThread[i].setName("消费者"+(i+1));
rThread[i].start();
}
}
}
将多生产多消费情况下的if判断条件改为while,就不会出现连续生产和连续消费问题,即使唤醒同类线程还是会执行while判断条件,如果条件为true则执行wait方法,避免了连续生产和连续消费的情况,但程序运行过程中却出现了假死,也就是所有的线程都呈现等待状态。“假死”的现象就是线程进入等待状态,如果全部线程都进入了等待状态,程序就不执行任何业务功能了,整个项目呈现等待状态。
上面的情况用一种简单情形解释:老爸老妈都会做饭,你和你哥都要吃饭。老妈做完饭通知你和你哥吃饭然后去休息(释放锁开始等待),老爸一看饭做好了,不用他去做了就去休息了(生产者唤醒生产者线程),你哥还是下班的路上,你先去吃饭,结果吃完了,然后还没心没肺的通知哥回来吃饭(消费者线程唤醒消费者线程),你哥到家后一看没有饭,也去休息了,这样所有的线程都休息了,所以出现了假死。假死出现的极大可能原因是连续唤醒了同类。解决假死的方法就是将notify通知换为notifyAll通知,这样就能顺利解决假死问题。
管道机制是线程之间消息传递的一种机制,Java语言提供了各种各样的输入输出流,使我们能够很方便地操作数据,其中管道流是一种特殊的流,用于在不同线程间之间传送数据。一个线程发送数据输出到管道,另一个线程从输入管道中读数据,通过使用管道,实现不同线程间的通信,而无须借助与临时文件之类的东西。
测试一:在管道中传递字节流
//输入管道
public class wirteMethod {
public void writMethod(PipedOutputStream out) //参数为管道
{
try {
System.out.println("wirte:");
for (int i = 0; i < 300; i++) {
String outData = "" + (i + 1);
out.write(outData.getBytes()); //向管道中写
System.out.print("~~~"+outData);
}
System.out.println();
out.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//输出管道
public class ReadDate {
public void readMethod(PipedInputStream input){
try{
System.out.println("read:");
byte[] byteArray=new byte[20];
int readLength=input.read(byteArray);
while (readLength!=-1)
{
String newData=new String(byteArray,0,readLength);
System.out.print("____"+newData);
readLength=input.read(byteArray);
}
System.out.println();
input.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
//输入线程
public class ThreadA extends Thread{
private wirteMethod wirteMethod;
private PipedOutputStream pipedOutputStream;
public ThreadA(wirteMethod wirteMethod,PipedOutputStream pipedOutputStream){
super();
this.wirteMethod=wirteMethod;
this.pipedOutputStream=pipedOutputStream;
}
@Override
public void run(){
wirteMethod.writMethod(pipedOutputStream);
}
}
//输出线程
public class ThreadB extends Thread{
private ReadDate readDate;
private PipedInputStream pipedInputStream;
public ThreadB(ReadDate readDate,PipedInputStream pipedInputStream){
super();
this.readDate=readDate;
this.pipedInputStream=pipedInputStream;
}
@Override
public void run(){
readDate.readMethod(pipedInputStream);
}
}
//测试
public class multithreadingtest {
public static void main(String[] args) throws IOException, InterruptedException {
wirteMethod wirteMethod=new wirteMethod();
ReadDate readDate=new ReadDate();
PipedInputStream inputStream=new PipedInputStream();
PipedOutputStream outputStream=new PipedOutputStream();
inputStream.connect(outputStream);
outputStream.connect(inputStream); //使两个管道之间产生通信链接
ThreadB readThread=new ThreadB(readDate,inputStream); //读线程先准备
readThread.setName("read");
readThread.start();
Thread.sleep(2000);
ThreadA wirteThread=new ThreadA(wirteMethod,outputStream);
wirteThread.setName("witte");
wirteThread.start();
}
}
从输出结果可以看出,首先是读线程启动,由于当前管道中没有数据被写入,所以线程阻塞,知道有数据写入才继续向下运行
测试二:在管道中传递字符流(基本同上,这里就不演示了)
利用wati/notify机制实现交叉备份:创建20个线程,其中10个线程是向数据库A中备份数据,另外10个线程向数据库B中备份数据,要满足备份工作是交叉进行的(往A备份,然后下次往B备份,轮流交叉),重点是如何利用wait/notify让20个线程变得有序
//备份数据的代码。
public class DBTools {
volatile private boolean prevIsa=false; //信号量
synchronized public void backupA(){ //A备份
try {
while(prevIsa==true){ //prevIsa为true,此时则等待
wait();
}
for (int i = 0; i < 5; i++) { //备份五次
System.out.println("&&&&&&&&&");
}
prevIsa=true;
notifyAll();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
synchronized public void backupB(){
try {
while(prevIsa==false){
wait();
}
for (int i = 0; i < 5; i++) {
System.out.println("*********");
}
prevIsa=false;
notifyAll();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//a备份线程
public class ThreadA extends Thread{
private DBTools dbTools;
public ThreadA(DBTools dbTools){
super();
this.dbTools=dbTools;
}
@Override
public void run(){
dbTools.backupA();
}
}
//b备份线程
public class ThreadB extends Thread{
private DBTools dbTools;
public ThreadB(DBTools dbTools){
super();
this.dbTools=dbTools;
}
@Override
public void run(){
dbTools.backupB();
}
}
//测试代码
public class multithreadingtest {
public static void main(String[] args) throws IOException, InterruptedException {
DBTools dbTools=new DBTools();
for (int i = 0; i < 20; i++) {
ThreadA threadA=new ThreadA(dbTools);
threadA.start();
ThreadB threadB=new ThreadB(dbTools);
threadB.start();
}
}
}
方法sleep()和Wait()的区别
(1) sleep()是Thread类中的方法,二wait()是Object中的方法
(2) sleep()可以不结合Sysnchronized使用 ,而wait()必须结合
(3) sleep()在执行时不会释放锁,而wait()在执行后锁被释放
(4) sleep()方法执行后线程的状态时TIMED_WAITING,wait()方法执行后线程的状态是等待