多線程_線程間通信

線程間通信：

　　多個線程在處理同一資源，但是他們的任務不同（一部分線程生產鴨子，另一部分線程銷售鴨子）

　　從下面的代碼開始，一步步的引出問題並解決

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //創建資源
    Inp a=new Inp(r);             //創建輸入任務
    Outp b=new Outp(r);          //創建輸出任務
    Thread t=new Thread(a);        //創建輸入線程，執行路徑（執行輸入任務）
    Thread t1=new Thread(b);    //創建輸出線程，執行路徑（執行輸出任務）
    t.start();       //開啟線程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true){
            if(a==0){
                r.name="黑";
                r.sex="男";
            }else{
                r.name="白白";
                r.sex="女女";
            }
            a=(a+1)%2;
        }
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
        System.out.println(r.name+"...."+r.sex);
    }
}

輸出的結果會出現這種情況：

              黑....女女
　　　　白白....男

會出現這種情況是因為有多個線程操作共享資源，並且操作共享資源的代碼有多條，可以用同步解決這種安全問題

修改后的代碼為：（就是簡單的加上一個鎖就可以解決問題，要保證線程使用的是同一個鎖）

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //創建資源
    Inp a=new Inp(r);             //創建輸入任務
    Outp b=new Outp(r);          //創建輸出任務
    Thread t=new Thread(a);        //創建輸入線程，執行路徑（執行輸入任務）
    Thread t1=new Thread(b);    //創建輸出線程，執行路徑（執行輸出任務）
    t.start();       //開啟線程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                   if(a==0){
                        r.name="黑";
                        r.sex="男";
                   }else{
                        r.name="白白";
                        r.sex="女女";
                 }
                 a=(a+1)%2;
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                 System.out.println(r.name+"...."+r.sex);
             }
    }
}

這樣雖然解決了安全問題，但是輸入（輸出）都是成片存在的，假設我們是在賣票，這樣就會出現一張票被重復賣出多次。

現在我就想，輸入一個，打印一個。這樣就引出了等待喚醒機制。

等待喚醒機制：

　　涉及的方法：

　　　　wait()  讓線程進入凍結狀態， 把線程存儲在線程池中

　　　　notify()  喚醒線程池中的一個線程

　　　　notifyall() 喚醒線程池中所有線程

　　　　這些方法都是操做線程狀態的  

　　　　這些方法必須定義在同步中  

　　　　這些方法必須明確屬於哪個鎖

             因為這些方法是監視器的方法，同步中一把鎖只能有一組監視器，鎖是任意的對象，任意的對象調用的方式一定定義在Object類，所以這些方法定義在Object類中。（我的理解，鎖調用這些方法去改變線程狀態，要保證鎖一定能調用這些方法，那就只能把這些方法定義在Object中）

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //創建資源
    Inp a=new Inp(r);             //創建輸入任務
    Outp b=new Outp(r);          //創建輸出任務
    Thread t=new Thread(a);        //創建輸入線程，執行路徑（執行輸入任務）
    Thread t1=new Thread(b);    //創建輸出線程，執行路徑（執行輸出任務）
    t.start();       //開啟線程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
    boolean bool=false;
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                      if(r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                   if(a==0){
                        r.name="黑";
                        r.sex="男";
                   }else{
                        r.name="白白";
                        r.sex="女女";
                 }
                 a=(a+1)%2;
                 r.bool=true;
                 r.notify();
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                 if(!r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                 System.out.println(r.name+"...."+r.sex);
                 r.bool=false;
                 r.notify(); 
             }
    }
}

這樣問題便得到了解決

可是我不滿足於現在的單線程輸入 單線程輸出；搞點猛地多線程輸入 多線程輸出。引出經典操作“多生產者多消費者”

多生產者多消費者：

　　在上面的代碼基礎上簡單的修改成買賣鴨子，並實現多生產者多消費者，看看會出什么問題：

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //創建資源
    Inp a=new Inp(r);             //創建輸入任務
    Outp b=new Outp(r);          //創建輸出任務
    Thread t0=new Thread(a);        //創建輸入線程，執行路徑（執行輸入任務）
    Thread t1=new Thread(a);    //創建輸出線程，執行路徑（執行輸出任務）
    Thread t2=new Thread(b);
    Thread t3=new Thread(b);
    t0.start();       //開啟線程
    t1.start();
    t2.start();
    t3.start();
    }
}
class Ziyuan{
    boolean bool=false;
    int a=0;
}
class Inp implements Runnable{
    Ziyuan r;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                      if(r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                      r.a++;
                      System.out.println(Thread.currentThread().getName()+"生產鴨子。。。"+r.a);
                 r.bool=true;
                 r.notify();
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                if(!r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                 System.out.println(Thread.currentThread().getName()+"賣出鴨子"+r.a--);
                 r.bool=false;
                 r.notify(); 
             }
    }
}

　　28 47 行使用的是if判斷，這就表示如果線程0在生產了鴨子后，凍結在28行處的1線程醒了，那么他不會在判斷，而是繼續生產鴨子，這就導致錯誤數據的出現（這時將if換成while）。

　　換成了while后發現，出現了死鎖情況（原因：比如.線程1.2.3已經進入了凍結狀態，線程0進凍結前，喚醒了t1線程，然后t1獲得了CPU的執行權，在t1進行了判斷后也進入了凍結狀態，這是所有的線程都進入了凍結狀態）。

　　只要我們保證一定能夠喚醒對方線程，那么就能解決問題，所以使用notifyAll()方法替換notify()方法就可以解決問題。

　　注意：1.if只有一次判斷，會導致不該運行的線程運行　　2.while判斷標記，解決了線程獲得執行權之后是否要運行的問題，如果while和notify一起使用會導致死鎖　　3.notifyAll解決了一定會喚醒對方線程的問題（如果己方線程總是獲得CPU執行權，那么效率會降低）

 

Lock接口和Condition接口

　　如果只是為了喚醒對方線程，而去喚醒所有線程，很明顯是不明智的，所以在JDK1.5版本后為我們提供了解決方法

　　Lock:  lock()獲取鎖　　unlock()釋放鎖　　ReentrantLock（已知實現子類）　　Lock代替了synchronized方法和語句的使用

　　Condition: await()凍結線程　　signal()喚醒一個線程　　signalAll()喚醒所有線程　　Condition代替了Objcet監視器方法的使用

　　同步中，一把鎖只能有一組監視器，但是Lock鎖已有多組Condition監視器

　　

　　如果線程發生了異常，那么鎖將無法釋放，所以unlock()一定要放在finally中

使用升級后的JDK所提供的方法重新寫代碼，提高效率

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class Text2 {
    public static void main(String[] args) {
        Ziyuan r=new Ziyuan();
        Inp in=new Inp(r);
        Outp out=new Outp(r);
        Thread t0=new Thread(in);
        Thread t1=new Thread(in);
        Thread t2=new Thread(out);
        Thread t3=new Thread(out);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    
    }
}
class Ziyuan{
    private String name;
    private String sex;
    private boolean bool=false;
    private int mun=1;
    Lock suo=new ReentrantLock();
    Condition inJian=suo.newCondition();
    Condition outJian=suo.newCondition();
    
    void show(String name){
        try{
            suo.lock();
            while(bool){
                try {inJian.await();} catch (InterruptedException e) {}
            }
            this.name=name+mun++;
            System.out.println(Thread.currentThread().getName()+"生產。。。"+this.name);
            bool=true;
            outJian.signal();
        }finally{
            suo.unlock();
        }
        
    }
    void show1(){
        try{
            suo.lock();
            while(!bool){
                try {outJian.await();} catch (InterruptedException e) {}
            }
            System.out.println(Thread.currentThread().getName()+"消費.................."+name);
            bool=false;
            inJian.signal();
        }finally{
            suo.unlock();
        }
        
    }
}
class Inp implements Runnable{
    Ziyuan r;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
           while(true){
               r.show("烤鴨");
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true){
            r.show1();
        }
    }
}

wait和sleep的區別：

　　1:wait可以指定時間，也可以不指定

　　　sleep一定要指定時間

　　2:wait釋放執行權，釋放鎖

　　　sleep釋放執行權，不釋放鎖

停止線程：

　　stop() 過時了，存在安全隱患

　　run() 方法結束（run方法運行完了，該線程會自動結束）（使用標記結束run方法），代碼如下：

class Producer implements Runnable
{
    int a=0;
    boolean bool=true; //標記
    public void run()
    {
        while(bool){
            System.out.println(Thread.currentThread().getName()+"          "+a++);
        }
    }
    public void set(boolean bool){   //修改標記，用來控制run()方法的結束
        this.bool=bool;
    }
    
}
class  ProducerConsumerDemo2
{
    public static void main(String[] args) 
    {
        Producer pro = new Producer();
        Thread t0 = new Thread(pro);
        t0.start();
        for(int i=0;i<500;i++){
            System.out.println(Thread.currentThread().getName()+".................."+i);
            if(i==499){
                pro.set(false);
            }
            
        }
        System.out.println(Thread.currentThread().getName()+"..................................."+"over");
    }
}

如果線程處於凍結狀態，那么利用標記來結束線程是行不通的；所以，Thread提供了interrupt()方法強制喚醒線程（因此會拋異常）

class Producer implements Runnable
{
    int a=0;
    boolean bool=true; //標記
    public synchronized void run()
    {
        while(bool){
            try {
                wait();
            } 
            catch (InterruptedException e) {
                bool=false;  //因為這中喚醒機制會發生InterruptedException異常，一定會運行catch 所以一般吧標記寫在catch中
            }
            System.out.println(Thread.currentThread().getName()+"          "+a++);
        }
    }    
}
class  ProducerConsumerDemo2
{
    public static void main(String[] args) 
    {
        Producer pro = new Producer();
        Thread t0 = new Thread(pro);
        t0.start();
        for(int i=0;i<500;i++){
            System.out.println(Thread.currentThread().getName()+".................."+i);
            if(i==499){
                t0.interrupt();
            }
            
        }
        System.out.println(Thread.currentThread().getName()+"..................................."+"over");
    }
}

守護線程（后台線程）：

　　steDaemon(boolean)    (當參數為true的時候這個線程為守護線程)  

　　　　　　　　　　  　　后台和前台線程基本一樣，唯一不同的就是，當前台線程全部運行結束后，后台線程也會跟着結束。（當正在運行的程序全都為守護線程的時候，JAVA虛擬機會自動退出）

 

　其他方法：

　　　join()　一般臨時加入一個線程執行運算，會調用這個方法（假設有t0 t1 main三個線程，如果t0調用了這個方法，那么主線程會凍結，t0 t1搶奪CPU的執行權，當t0運算完成，main才接觸凍結狀態）

　　　setPriority(int)  設置線程的優先級（1-10）一般分為三個等級（1-5-10）注意並不是設置成了10這個最高級，這個線程就會拼命運行，只不過是CPU比較照顧一點。