转载自:http://blog.csdn.net/watermusicyes/article/details/8804530
在开始讲解等待唤醒机制之前,有必要搞清一个概念——
线程之间的通信:
多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制所涉及到的方法:
wait() :等待,将正在执行的线程释放其执行资格 和 执行权,并存储到线程池中。
notify():唤醒,唤醒线程池中被wait()的线程,一次唤醒一个,而且是任意的。
notifyAll(): 唤醒全部:可以将线程池中的所有wait() 线程都唤醒。
其实,所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是,这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁,这样才可以明确出这些方法操作的到底是哪个锁上的线程。
仔细查看JavaAPI之后,发现这些方法 并不定义在 Thread中,也没定义在Runnable接口中,却被定义在了Object类中,为什么这些操作线程的方法定义在Object类中?
因为这些方法在使用时,必须要标明所属的锁,而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。
接下里,我们先从一个简单的示例入手:
如上图说示,输入线程 想Resource中输入name ,sex , 输出线程从资源中输出,先要完成的任务是:
1. 当input发现Resource中没有数据时,开始输入,输入完成后,叫output来输出。如果发现有数据,就wait();
2. 当output发现Resource中没有数据时,就wait() ;当发现有数据时,就输出,然后,叫醒input来输入数据。
这个问题的关键在于,如何来做到 交替进行。
下面看具体的代码实现:
public class Resource {
private String name ;
private String sex;
private boolean flag = false;
public synchronized void set(String name , String sex){
if(flag)
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//设置成员变量
this.name = name;
this.sex = sex;
//设置之后,Resource中有值,将标记该为 true ,
flag = true;
//唤醒output
this.notify();
}
public synchronized void out(){
if(!flag)
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//输出线程将数据输出
System.out.println("The name is : " + name + " && The sex is : " + sex);
//改变标记,以便输入线程输入数据
flag = false;
//唤醒input,进行数据输入
this.notify();
}
}
public class Input implements Runnable {
private Resource r;
public Input(Resource r){
this.r = r;
}
@Override
public void run() {
int count = 0 ;
while(true){
if(count == 0){
r.set("Tom", "man");
}else{
r.set("Lily", "woman");
}
//在连个数据之间进行切换。
count = (count + 1)%2;
}
}
}
public class Output implements Runnable {
private Resource r ;
public Output(Resource r ){
this.r = r;
}
@Override
public void run() {
while(true){
r.out();
}
}
}
public class ResourceDemo {
public static void main(String[] args) {
//资源对象
Resource r = new Resource();
//任务对象
Input in = new Input(r);
Output out = new Output(r);
//线程对象
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
//开启线程
t1.start();
t2.start();
}
}
在这个例子中,我们应用了等待唤醒机制,这是最简单的应用,下面我们来看看等待唤醒机制的经典问题:生产者,消费者问题!
当然也是,从最简单的问题开始看起:即单个消费者,生产者。这个例子和上个例子极其相似,因此不再赘述。接下来,主要谈一下,多生产者,多消费者的情形。
看下例子代码:
public class Resource {
private String name;
private int count = 1;
private boolean flag ;
public synchronized void set(String name){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName()
+ "The producer name is :++++++++++++++ " + this.name);
flag = true;
this.notify();
}
public synchronized void out(){
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() +
"The consumer name is : ---------------------------" + this.name);
flag = false;
this.notify();
}
}
public class Producer implements Runnable {
private Resource r;
public Producer(Resource r){
this.r = r;
}
@Override
public void run() {
while(true){
r.set("馒头");
}
}
}
public class Consumer implements Runnable {
private Resource r;
public Consumer(Resource r ){
this.r = r;
}
@Override
public void run() {
while(true){
r.out();
}
}
}
public class ProConDemo {
public static void main(String[] args) {
//资源对象
Resource r = new Resource();
//任务对象
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
//线程对象,两个生产者,两个消费者
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
//开启线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
发现:生产者生产的商品没有被消费就生产了新的商品。
经过分析,发现,产生这种状况的根源是:
1,本方唤醒了本方。
2,被唤醒的本方没有判断标记。
为此,我们要做的改进是——将if 判断改为 while 标记,保证,每次被wait的线程在醒了之后,都得再次判断标记。进过修改,再次运行之后,会发现新的问题又来了,产生了死锁。经过分析,这个问题的根源在于,本方唤醒了本方,被唤醒的本方判断标记后,发现,标记不成立,就继续等待,因此,再也没有活着的线程。为此,我们需要唤醒,所有的线程,就用到了 notifyAll() 。将线程池中,所有等待的线程都叫醒。
经过修改后的代码成功的解决了上述的问题。
修改后的代码为:
public class Resource {
private String name;
private int count = 1;
private boolean flag ;
public synchronized void set(String name){
//用while 确保线程醒了后再次,判断标记。
while(flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName()
+ "The producer name is :++++++++++++++ " + this.name);
flag = true;
//唤醒所有被等待的线程
this.notifyAll();
}
public synchronized void out(){
//用while 确保线程醒了后再次,判断标记。
while(!flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() +
"The consumer name is : ---------------------------" + this.name);
flag = false;
//唤醒所有被等待的线程
this.notifyAll();
}
}
使用JDK的1.5版本以后可以解决一个对象只能有一个锁的问题:
<pre name="code" class="java">package thread_Demo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Resoucen
{
private String name;
private int num;
public boolean flag = false;
private final Lock lock = new ReentrantLock();
private Condition con = lock.newCondition();
public void set(String name, int num)
{
// synchronized (this) {
lock.lock();
while(flag)
{
try
{
con.await();
} catch (InterruptedException e){}
}
this.name = name;
this.num = num;
con.signal();
flag = true;
lock.unlock();
//}
}
public void out()
{
//synchronized (this) {
lock.lock();
while(!flag)
try
{
con.await();
}catch(InterruptedException e){}
System.out.println(this.name + "......new...." + this.num);
con.signal();
flag = false;
lock.unlock();
// }
}
}
class Inputn implements Runnable
{
private Resoucen r;
Inputn( Resoucen r)
{
this.r = r;
}
public void run()
{
int count = 0;
while(true)
{
if(count % 2 == 0)
{
r.set("小米", 19);
}
else
{
r.set("小名", 20);
}
++count;
}
}
}
class Outputn implements Runnable
{
private Resoucen r;
Outputn( Resoucen r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}
public class NewProduceConsumerDemo {
/**
* 本程序掩饰多线程的停止等待机制 使用的是JDK的1.5版本以后的Condition和ReentrantLock
*/
public static void main(String[] args) {
Resoucen r = new Resoucen();
Inputn in = new Inputn(r);
Outputn ou = new Outputn(r);
new Thread(in).start();
new Thread(ou).start();
}
}