Java 多線程（七） 線程間的通訊——wait及notify方法

標籤：

線程間的相互作用

　　線程間的相互作用：線程之間需要一些協調通訊，來共同完成一件任務。

　　Object類中相關的方法有兩個notify方法和三個wait方法：

　　http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html

　　因為wait和notify方法定義在Object類中，因此會被所有的類所繼承。

　　這些方法都是final的，即它們都是不能被重寫的，不能通過子類覆寫去改變它們的行為。

 wait()方法

　　wait()方法使得當前線程必須要等待，等到另外一個線程調用notify()或者notifyAll()方法。

　　當前的線程必須擁有當前對象的monitor，也即lock，就是鎖。

　　線程調用wait()方法，釋放它對鎖的擁有權，然後等待另外的線程來通知它（通知的方式是notify()或者notifyAll()方法），這樣它才能重新獲得鎖的擁有權和恢複執行。

　　要確保調用wait()方法的時候擁有鎖，即，wait()方法的調用必須放在synchronized方法或synchronized塊中。

 

　　一個小比較：

　　當線程調用了wait()方法時，它會釋放掉對象的鎖。

　　另一個會導致線程暫停方法：Thread.sleep()，它會導致線程睡眠指定的毫秒數，但線程在睡眠的過程中是不會釋放掉對象的鎖的。

 notify()方法

　　notify()方法會喚醒一個等待當前對象的鎖的線程。

　　如果多個線程在等待，它們中的一個將會選擇被喚醒。這種選擇是隨意的，和具體實現有關。（線程等待一個對象的鎖是由於調用了wait方法中的一個）。

　　被喚醒的線程是不能被執行的，需要等到當前線程放棄這個對象的鎖。

　　被喚醒的線程將和其他線程以通常的方式進行競爭，來獲得對象的鎖。也就是說，被喚醒的線程並沒有什麼優先權，也沒有什麼劣勢，對象的下一個線程還是需要通過一般性的競爭。

　　notify()方法應該是被擁有對象的鎖的線程所調用。

　　（This method should only be called by a thread that is the owner of this object‘s monitor.）

　　換句話說，和wait()方法一樣，notify方法調用必須放在synchronized方法或synchronized塊中。

 

　　wait()和notify()方法要求在調用時線程已經獲得了對象的鎖，因此對這兩個方法的調用需要放在synchronized方法或synchronized塊中。

　　一個線程變為一個對象的鎖的擁有者是通過下列三種方法：

　　1.執行這個對象的synchronized執行個體方法。

　　2.執行這個對象的synchronized語句塊。這個語句塊鎖的是這個對象。

　　3.對於Class類的對象，執行那個類的synchronized、static方法。

 

程式執行個體

　　利用兩個線程，對一個整形成員變數進行變化，一個對其增加，一個對其減少，利用線程間的通訊，實現該整形變數0101這樣交替的變更。

NumberTest

public class NumberHolder
{
private int number;

public synchronized void increase()
{
if (0 != number)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}

// 能執行到這裡說明已經被喚醒
// 並且number為0
number++;
System.out.println(number);

// 通知在等待的線程
notify();
}

public synchronized void decrease()
{
if (0 == number)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}

}

// 能執行到這裡說明已經被喚醒
// 並且number不為0
number--;
System.out.println(number);
notify();
}

}

 

public class IncreaseThread extends Thread
{
private NumberHolder numberHolder;

public IncreaseThread(NumberHolder numberHolder)
{
this.numberHolder = numberHolder;
}

@Override
public void run()
{
for (int i = 0; i < 20; ++i)
{
// 進行一定的延時
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}

// 進行增加操作
numberHolder.increase();
}
}

}

 

public class DecreaseThread extends Thread
{
private NumberHolder numberHolder;

public DecreaseThread(NumberHolder numberHolder)
{
this.numberHolder = numberHolder;
}

@Override
public void run()
{
for (int i = 0; i < 20; ++i)
{
// 進行一定的延時
try
{
Thread.sleep((long) Math.random() * 1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}

// 進行減少操作
numberHolder.decrease();
}
}

}

 

public class NumberTest
{
public static void main(String[] args)
{
NumberHolder numberHolder = new NumberHolder();

Thread t1 = new IncreaseThread(numberHolder);
Thread t2 = new DecreaseThread(numberHolder);

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

}

public class NumberHolder{    private int number;    public synchronized void increase()    {        if (0 != number)        {            try            {                wait();            }            catch (InterruptedException e)            {                e.printStackTrace();            }        }        // 能執行到這裡說明已經被喚醒        // 並且number為0        number++;        System.out.println(number);        // 通知在等待的線程        notify();    }    public synchronized void decrease()    {        if (0 == number)        {            try            {                wait();            }            catch (InterruptedException e)            {                e.printStackTrace();            }        }        // 能執行到這裡說明已經被喚醒        // 並且number不為0        number--;        System.out.println(number);        notify();    }}public class IncreaseThread extends Thread{    private NumberHolder numberHolder;    public IncreaseThread(NumberHolder numberHolder)    {        this.numberHolder = numberHolder;    }    @Override    public void run()    {        for (int i = 0; i < 20; ++i)        {            // 進行一定的延時            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            // 進行增加操作            numberHolder.increase();        }    }}public class DecreaseThread extends Thread{    private NumberHolder numberHolder;    public DecreaseThread(NumberHolder numberHolder)    {        this.numberHolder = numberHolder;    }    @Override    public void run()    {        for (int i = 0; i < 20; ++i)        {            // 進行一定的延時            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            // 進行減少操作            numberHolder.decrease();        }    }}public class NumberTest{    public static void main(String[] args)    {        NumberHolder numberHolder = new NumberHolder();                Thread t1 = new IncreaseThread(numberHolder);        Thread t2 = new DecreaseThread(numberHolder);                        t1.start();        t2.start();    }}

　　

　　如果再多加上兩個線程呢？

　　即把其中的NumberTest類改為如下：

NumberTest 4線程

public class NumberTest
{
public static void main(String[] args)
{
NumberHolder numberHolder = new NumberHolder();

Thread t1 = new IncreaseThread(numberHolder);
Thread t2 = new DecreaseThread(numberHolder);

Thread t3 = new IncreaseThread(numberHolder);
Thread t4 = new DecreaseThread(numberHolder);

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

t3.start();
t4.start();
}

}

public class NumberTest{    public static void main(String[] args)    {        NumberHolder numberHolder = new NumberHolder();                Thread t1 = new IncreaseThread(numberHolder);        Thread t2 = new DecreaseThread(numberHolder);                Thread t3 = new IncreaseThread(numberHolder);        Thread t4 = new DecreaseThread(numberHolder);                        t1.start();        t2.start();                t3.start();        t4.start();    }}

 

　　運行後發現，加上t3和t4之後結果就錯了。

　　為什麼兩個線程的時候執行結果正確而四個線程的時候就不對了呢？

　　因為線程在wait()的時候，接收到其他線程的通知，即往下執行，不再進行判斷。兩個線程的情況下，喚醒的肯定是另一個線程；但是在多個線程的情況下，執行結果就會混亂無序。

　　比如，一個可能的情況是，一個增加線程執行的時候，其他三個線程都在wait，這時候第一個線程調用了notify()方法，其他線程都將被喚醒，然後執行各自的增加或減少方法。

　　解決的方法就是：在被喚醒之後仍然進行條件判斷，去檢查要改的數字是否滿足條件，如果不滿足條件就繼續睡眠。把兩個方法中的if改為while即可。

NumberHolder 4線程

public class NumberHolder
{
private int number;

public synchronized void increase()
{
while (0 != number)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}

// 能執行到這裡說明已經被喚醒
// 並且number為0
number++;
System.out.println(number);

// 通知在等待的線程
notify();
}

public synchronized void decrease()
{
while (0 == number)
{
try
{
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}

}

// 能執行到這裡說明已經被喚醒
// 並且number不為0
number--;
System.out.println(number);
notify();
}

}

public class NumberHolder{    private int number;    public synchronized void increase()    {        while (0 != number)        {            try            {                wait();            }            catch (InterruptedException e)            {                e.printStackTrace();            }        }        // 能執行到這裡說明已經被喚醒        // 並且number為0        number++;        System.out.println(number);        // 通知在等待的線程        notify();    }    public synchronized void decrease()    {        while (0 == number)        {            try            {                wait();            }            catch (InterruptedException e)            {                e.printStackTrace();            }        }        // 能執行到這裡說明已經被喚醒        // 並且number不為0        number--;        System.out.println(number);        notify();    }}

 

 

參考資料

　　聖思園張龍老師Java SE系列視頻教程。

Java 多線程（七） 線程間的通訊——wait及notify方法