Java多线程编程四(线程间通信)

等待和通知机制

两个线程互相通信数据

编码两个线程如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class NotifyThread extends Thread {
private List<String> list;
public NotifyThread(List<String> list) {
this.list = list;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
list.add(String.valueOf(i));
System.out.println("添加了" + (i + 1) + "个元素");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public class BeCalledThread extends Thread {
private List<String> list;
public BeCalledThread(List<String> list) {
this.list = list;
}
@Override
public void run() {
while (true) {
System.out.println("判断大小");
if (list.size() == 5) {
System.out.println("list的大小等于5了,此线程要退出了");
return;
}
}
}
}

public static void main (String[] args) {
ArrayList<String> list = new ArrayList<String>();
NotifyThread notifyThread = new NotifyThread(list);
BeCalledThread beCalledThread = new BeCalledThread(list);
notifyThread.start();
beCalledThread.start();
}

其中NotifyThread线程和BeCalledThread共享一个list,NotifyThread线程每一秒向list里添加数据,而BeCalledThread线程则检测list的大小,结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
...
判断大小
判断大小
判断大小
判断大小
判断大小
判断大小
判断大小
判断大小
添加了5个元素
list的大小等于5了,此线程要退出了
添加了6个元素
添加了7个元素
添加了8个元素
添加了9个元素
添加了10个元素

由于BeCalledThread一直在不停快速的查询list的大小,所以导致NotifyThread前添加数据的日志无法呈现出来,很快的就被覆盖掉了,由此可知,这样的做法是非常消耗资源的,所以就诞生里“等待/通信“机制来解决优化这个问题。

等待/通信机制

简单通俗的讲,等待通信机制就是:线程a和线程b,线程a执行任务的前提需要某个条件成立,而这个条件并不成立,线程a并不需要隔一段时间或者是不停去查询这个条件是否成立,而是进入等待状态,而线程b执行任务时将线程a需要的条件构建成立,此时会通知正在等待的线程a,告诉线程a此条件已经成立,然后线程a就可以做后续的操作。(就好比酒店里,客人点餐,服务员不需要不停询问厨房是否做好,而是等待厨房做好了通知服务员来取餐)

相关方法:

  • wait()的作用是使当前执行代码的线程进行等待。wait()方法是Object类的方法,该方法用来将当前线程置入“预执行队列”中,并且在wait()所在的代码行处停止执行,直到接到通知或者被中断位置。在调用wait()之前,线程必须获得该对象的对象级别锁,即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后,当前线程释放锁。在从wait()返回前,线程与其他线程竞争重新获得锁。如果调用wait()时没有持有适当的锁,则抛出IllegalMonitorStateException,它是RuntimeException的一个子类,因此,不需要try-catch语句进行捕捉异常。

  • notify()也要在同步方法或同步块中调用,即在调用前,线程也必须获得该对象的对象级别锁。如果调用notify()时没有持有适当的锁,也会抛出lllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程,如果有多个线程等待,则由线程规划器随机挑选出其中一个呈wait状态的线程,对其发出通知notify,并使它等待获取该对象的对象锁。需要说明的是,在执行notify()方法后,当前线程不会马上释放该对象锁,呈wait状态的线程也并不能马上获取该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出synchronized代码块后,当前线程才会释放锁,而呈wait状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后,它会释放掉该对象锁,此时如果该对象没有再次使用notify语句,则即便该对象已经空闲,其他wait状态等待的线程由于没有得到该对象的通知,还会继续阻塞在wait状态,直到这个对象发出一个notifynotifyAll

总结:wait使线程停止运行,而notify使停止的线程继续运行。

  • 关键字synchronized可以将任何一个Object对象作为同步对象来看,而Java为每个Object都实现了wait()notify()方法,他们必须用在被synchronized同步的Object的临界区内。通过调用wati方法可以使处于临界区的线程进入等待状态,同时释放被同步对象的锁。而notify操作可以唤醒一个因调用了wait操作而处于阻塞状态中的线程,使其进入就绪状态。被重新唤醒的线程会试图重新获取临界区的控制权,也就是锁,并继续执行临界区内wait之后的代码。如果发出notify操作时没有处于阻塞状态中的线程,那么该命令会被忽略。

  • wait()方法可以使调用该方法的线程释放共享资源的锁,然后从运行状态退出,进入等待队列,直到被再次唤醒。

  • notify()方法可以随机唤醒等待队列中等待同一共享资源的“一个”线程,并使该线程退出等待队列,进入可运行状态,也就是notify()方法仅随机通知“一个”线程。

  • notifyAll()方法可以使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出,进入可运行状态。此时优先级最高的那个最先执行,但也有可能使随机执行,因为这个要取决于JVM虚拟机的实现。

  • wait()方法释放锁,notify()不释放锁,只有执行完notify()所在的同步synchronized代码块以后才释放锁。

  • 当线程呈wait()状态时,调用线程对象的interrupt()方法会出现InterruptedException`异常。

  • 在执行同步代码块的过程中,发生了异常而导致线程终止,锁也会被释放。

  • wait(long)方法的功能是等待某一时间内是否有线程对锁进行唤醒,如果超过这个时间则自动唤醒。提醒:在使用wait/notify模式时,还需要注意另一种情况,也就是wait等待的条件发生了变化,也容易造成程序逻辑的混乱。

方法join的使用

  • join():很多情况下,主线程创建并启动子线程,如果子线程中要进行大量的耗时运算,主线程往往将早于子线程结束之前结束。这时如果主线程想等待子线程执行完成后再结束,如子线程处理一个数据,主线程要取得这个数据中的值,就要使用join()方法。方法join()的作用是等待线程对象销毁。
  • join(long):等待指定时间,过后不再等待。
  • 方法join()interrupt()方法如果彼此遇到,则会出现异常。
  • 方法join()是由wait(long)方法来实现的,所以其具有释放锁的特点,也就是当执行join()方法时,会获取到线程本身对象锁,然后再释放。而Thread.sleep(long)方法却不释放锁。

方法join()后面的代码提前运行:出现意外

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class ThreadB extends Thread {

@Override
synchronized public void run() {
try {
System.out.println("begin B ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println(" end B ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public class ThreadA extends Thread {
private ThreadB b;
public ThreadA(ThreadB b) {
this.b = b;
}
@Override
public void run() {
synchronized (b) {
try {
System.out.println("begin A ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println(" end A ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public static void main (String[] args) throws InterruptedException {
ThreadB b = new ThreadB();
ThreadA a = new ThreadA(b);
a.start();
b.start();
b.join(2000);
System.out.println("main end " + System.currentTimeMillis());
}

运行结果如下:

  • b.join(2000)
1
2
3
4
5
begin A ThreadName=Thread-1 1587347117570
end A ThreadName=Thread-1 1587347122585
main end 1587347122586
begin B ThreadName=Thread-0 1587347122586
end B ThreadName=Thread-0 1587347127586
1
2
3
4
5
begin A ThreadName=Thread-1 1587349007103
end A ThreadName=Thread-1 1587349012106
begin B ThreadName=Thread-0 1587349012106
main end 1587349012106
end B ThreadName=Thread-0 1587349017107
1
2
3
4
5
begin B ThreadName=Thread-0 1587362103612
end B ThreadName=Thread-0 1587362108613
main end 1587362108613
begin A ThreadName=Thread-1 1587362108613
end A ThreadName=Thread-1 1587362113613
  • b.join()
1
2
3
4
5
begin A ThreadName=Thread-1 1587362888058
end A ThreadName=Thread-1 1587362893059
begin B ThreadName=Thread-0 1587362893059
end B ThreadName=Thread-0 1587362898059
main end 1587362898059
1
2
3
4
5
begin A ThreadName=Thread-1 1587362962560
end A ThreadName=Thread-1 1587362967561
begin B ThreadName=Thread-0 1587362967561
end B ThreadName=Thread-0 1587362972562
main end 1587362972562

为了解释这个现象需要更改上诉代码,将main程序中的join方法注释掉运行:

1
2
3
4
5
main end 1587362228606
begin A ThreadName=Thread-1 1587362228607
end A ThreadName=Thread-1 1587362233608
begin B ThreadName=Thread-0 1587362233608
end B ThreadName=Thread-0 1587362238609
1
2
3
4
5
main end 1587362278637
begin A ThreadName=Thread-1 1587362278638
end A ThreadName=Thread-1 1587362283639
begin B ThreadName=Thread-0 1587362283639
end B ThreadName=Thread-0 1587362288639
1
2
3
4
5
main end 1587362425653
begin A ThreadName=Thread-1 1587362425665
end A ThreadName=Thread-1 1587362430666
begin B ThreadName=Thread-0 1587362430666
end B ThreadName=Thread-0 1587362435666

有结果来看,大部分都是System.out.println("main end " + System.currentTimeMillis());先执行,也就是说如果去掉之前的join()方法的注释,那么也就很大几率先运行,由于join()是同步方法,也就会获取锁b,然后释放锁b,再由线程A和线程B来争抢锁b,假如线程A先抢到锁b,那么执行打印begin,然后sleep且不释放锁,再打印end,执行完毕并释放锁b,此时再由之前运行的join()方法和线程B来争抢锁b,谁抢到就谁运行或者继续运行,结果就出现了一些不确定的打印结果的顺序。

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :