Java基礎學習筆記之多執行緒

阿新 • • 發佈：2019-01-20

Java基礎之多執行緒

1.程序與執行緒

1）程序和執行緒都是一個時間段的描述，是CPU工作時間段的描述。

程序與執行緒都能夠完成多工
你打開了QQ，你開了一個程序，你打開了微信，你又開了一個程序，在QQ的這個程序裡，你與一個人的聊天開一個執行緒，與另一個人聊天再開一個執行緒。

2）程序與執行緒的概述

程序：是系統進行資源分配和排程的一個獨立單元
執行緒：是程序的一個實體，是CPU排程和分配的基本單位，是比程序更小的能獨立執行的基本單位

3)程序與執行緒的區別

1.一個程式至少有一個程序，一個程序至少有一個執行緒
2.執行緒的劃分尺度小於程序，使得多執行緒的併發性高
3.程序在執行過程中擁有獨立的記憶體單元，而多個執行緒共享記憶體
4.執行緒必須依賴於程序中才能執行
總的來說，程序是執行緒的老子，執行緒是程序下的一個執行單位

4)並行與併發

併發是指兩個及兩個以上事件在同一時間間隔執行。
並行是指在兩個及兩個以上的事件在同一時刻執行。

這裡寫圖片描述
併發是兩個佇列交替使用一臺咖啡機，並行是兩個佇列同時使用兩臺咖啡機（參考知乎）

2.執行緒的建立

執行緒的建立有兩種方法

方法一，通過繼承java.lang .Thread類，重寫run方法
方法二，實現java.lang .Runnable介面，實現run方法

方法一，繼承Thread類

步驟：
1.建立一個類繼承Thread，重寫run方法
2.建立這個類例項
3.使用start()方法啟動執行緒，啟動後會併發的執行run()方法
例如：

/*
 * 方法一
 * 1.建立類繼承Thread
 */
class CreateThread1 extends Thread{
    //2.重寫run方法
    public void run() { 
        /*
         * 執行緒方法體
         */
        System.out.println("執行緒：" + Thread.currentThread().getName() + " 啟動了");
        //Thread.currentThread().getName() 獲取當前執行的執行緒名
    }
}
public class 
 TestThread {
    public static void main(String[] args) {    
        //3.建立繼承類物件
        CreateThread1 ct1 = new CreateThread1();
        //4.啟動執行緒
        ct1.start();
    }   
}

結果：

執行緒：Thread-0 啟動了

方法二，實現Runnable介面

步驟：
1.建立一個類實現Runnable介面，實現run方法
2.建立這個類例項，將此例項作為Thread構造器的引數，建立Thread類例項
3.使用start()方法啟動執行緒，啟動後會併發的執行run()方法
例如：

/*
 * 方法二
 * 1.建立類實現Runnable介面
 */
class CreateThread2 implements Runnable{
    public void run() {
        System.out.println("執行緒：" + Thread.currentThread().getName() + " 啟動了");
    }
}
public class TestThread {
    public static void main(String[] args) {    
        //3.建立繼承類物件
        CreateThread2 ct2 = new CreateThread2();
        //4.將類例項作為Thread構造器的引數建立Thread物件
        Thread th2 = new Thread(ct2);
        //4.啟動執行緒
        th2.start();
    }   
}

結果：

執行緒：Thread-0 啟動了

3.Thread類的常用方法

1）常用構造方法

Thread() 
分配一個新的 Thread物件。 

Thread(Runnable target) 
分配一個新的 Thread物件。

Thread(Runnable target, String name) 
分配一個新的 Thread物件。  

Thread(String name) 
分配一個新的 Thread物件。

2）常用方法

1）getName() 返回執行緒的名字

2）setPriority(int newPriority) 設定執行緒的優先順序 
   （最低優先順序，MIN_PRIORITY：1    預設優先順序，NORM_PRIORITY：5   最大優先順序，MAX_PRIORITY：10）
    設定優先順序只是增加獲得CPU資源的概率

3）getPriority() 返回此執行緒的優先順序

4）getState() 返回此執行緒的狀態

5）isAlive() 判斷執行緒是否存活

6）join() 等待呼叫此方法的執行緒死亡

7）setName(String name) 設定執行緒的名字

8）sleep(long millis) 使執行緒睡眠，單位為毫秒

9）start() 開始執行執行緒

10）yield() 放棄當前執行權

11）currentThread() 返回當前正在執行的執行緒

4.執行緒的生命週期

這裡寫圖片描述

執行緒生命週期中有五個狀態

a)新建（New Thread）
當用new操作符建立一個新的執行緒物件時，該執行緒處於新建狀態。
此時執行緒還未啟動，當執行緒物件呼叫start()方法時執行緒啟動，進入Runnable(就緒)狀態

b)就緒（Runnable）
執行緒已經準備就緒，等待獲取CPU。
start()即就緒。

c)執行（Running）
執行緒獲得CPU資源，進入Running狀態，開始執行執行緒體，即run()方法中的內容。
呼叫yield()方法可以使執行緒由Running狀態進入Runnable狀態（執行狀態->就緒狀態）

d)阻塞（Blocked）
當正在執行的執行緒被阻塞時，其他執行緒就獲得了執行的機會
正在執行的執行緒因sleep()或wait()或其他執行緒join()等而使執行緒暫停執行讓出資源進入等待（阻塞）。
當sleep()時間結束或被喚醒nontify()或其他執行緒執行完畢，執行緒由阻塞狀態進入就緒狀態。

e)消亡（Dead）
當執行緒的run()方法執行結束，執行緒進入死亡狀態，執行緒死亡後將不能再次作為執行緒執行

5.執行緒的安全

1）執行緒存在安全問題的原因

由於執行緒在操作共享資料的過程中，在未執行完的情況下其他執行緒參與進來，導致共享資料出現了安全問題
例如：

class TestThread1 implements Runnable{
    static int num = 10;//設定總數為10
    public void run() {
        while(true) {
            if(num>0) { //當num大於0時，列印此時num的數值，num減一
                try {
                    Thread.sleep(10);//增加出錯機率
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + num--);
            }
        }
    }
}
public class TestThread2 {
    public static void main(String[] args) {
        TestThread1 tt1 = new TestThread1();
        //建立兩個執行緒
        Thread t1 = new Thread(tt1);
        Thread t2 = new Thread(tt1);
        //啟動兩個執行緒
        t1.start();
        t2.start();
    }
}

結果：

Thread-0:10
Thread-1:9
Thread-0:8
Thread-1:7
Thread-1:6
Thread-0:6
Thread-1:4
Thread-0:5
Thread-1:3
Thread-0:2
Thread-0:1
Thread-1:0

由於我們需要列印的時大於0的數，所以當控制檯結果出現0，就表明執行緒出現了安全的問題

2）如何解決執行緒安全問題

必須讓一個執行緒操作完共享資料後，其他執行緒才能參與共享資料的操作

3）Java如何建立執行緒安全(執行緒的同步機制 Synchronized的使用方法)

方法一，同步程式碼塊

            Synchronized(物件){
                //需要被同步的程式碼
            }

a) 共享資料：多個執行緒共同操作同一個資料
b) 同步監視器：由一個任意類的物件來充當，哪個物件獲得了此監視器，誰就執行大括號內被同步的程式碼，俗稱：鎖
要求：所有的執行緒必須共用一把鎖
c) 注：在實現的方法中，使用同步的話可以考慮用this來充當物件，在繼承的方法中，則要考慮是否是同一個物件，慎用this
d) 對於靜態方法而言可以使用當前類本身充當鎖類名.class

例子：
1.使用實現的方法建立執行緒

/*
 * 模擬火車取票
 */
class TestTicket1 implements Runnable{
    private int ticket = 20;//假設火車票總共20張
    public void run() {
        //使用同步程式碼塊
        //多個執行緒必須使用同一把鎖，由於當前是實現Runnable介面建立執行緒，多個執行緒可以共享一個Runnable子類物件，所以可以使用this（當前物件）來作為鎖
        //如果使用繼承的方法可以在類裡面建立物件作為鎖，或者以外傳入物件作為鎖
        //作為鎖的物件可以是任意物件
        while (true) {
            synchronized (this) {
                if (this.ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("當前執行緒是：" + Thread.currentThread().getName() + "：" + this.ticket--);
                }
            }
        }
    }
}
public class TestThread3 {
    public static void main(String[] args) {
        TestTicket1 tt1 = new TestTicket1();
        // 建立執行緒
        Thread t1 = new Thread(tt1);
        Thread t2 = new Thread(tt1);
        Thread t3 = new Thread(tt1);
        // 為執行緒起名
        t1.setName("執行緒1");
        t2.setName("執行緒2");
        t3.setName("執行緒3");
        // 啟動執行緒
        t1.start();
        t2.start();
        t3.start();
    }
}

結果：

當前執行緒是：執行緒1：20
當前執行緒是：執行緒1：19
當前執行緒是：執行緒1：18
當前執行緒是：執行緒1：17
當前執行緒是：執行緒1：16
當前執行緒是：執行緒2：15
當前執行緒是：執行緒2：14
當前執行緒是：執行緒2：13
當前執行緒是：執行緒2：12
當前執行緒是：執行緒2：11
當前執行緒是：執行緒3：10
當前執行緒是：執行緒3：9
當前執行緒是：執行緒3：8
當前執行緒是：執行緒3：7
當前執行緒是：執行緒3：6
當前執行緒是：執行緒3：5
當前執行緒是：執行緒3：4
當前執行緒是：執行緒3：3
當前執行緒是：執行緒3：2
當前執行緒是：執行緒3：1

2.使用繼承的方法建立執行緒

/*
 * 火車購票
 */
class TestThread4 extends Thread{
    /*
     * 使用繼承的方式
     * 
     */
    static int ticket = 20;
    Object obj;//同步鎖

    public TestThread4(Object obj) {
        this.obj = obj;//傳入鎖
    }

    public void run() {
            while (true) {
                synchronized (obj) {
                    if (this.ticket > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println("當前執行緒是：" + Thread.currentThread().getName() + "：" + this.ticket--);
                    }
                }
            }       
    }
}
public class TestThread3 {
    public static void main(String[] args) {
        //建立同步鎖
        Object obj = new Object();
        // 建立執行緒
        TestThread4 t1 = new TestThread4(obj);
        TestThread4 t2 = new TestThread4(obj);
        TestThread4 t3 = new TestThread4(obj);
        // 為執行緒起名
        t1.setName("執行緒1");
        t2.setName("執行緒2");
        t3.setName("執行緒3");
        // 啟動執行緒
        t1.start();
        t2.start();
        t3.start();
    }
}

結果：

當前執行緒是：執行緒1：20
當前執行緒是：執行緒1：19
當前執行緒是：執行緒1：18
當前執行緒是：執行緒1：17
當前執行緒是：執行緒2：16
當前執行緒是：執行緒2：15
當前執行緒是：執行緒2：14
當前執行緒是：執行緒2：13
當前執行緒是：執行緒2：12
當前執行緒是：執行緒2：11
當前執行緒是：執行緒3：10
當前執行緒是：執行緒3：9
當前執行緒是：執行緒3：8
當前執行緒是：執行緒3：7
當前執行緒是：執行緒3：6
當前執行緒是：執行緒3：5
當前執行緒是：執行緒3：4
當前執行緒是：執行緒3：3
當前執行緒是：執行緒3：2
當前執行緒是：執行緒3：1

注：在實現的方法中，使用同步的話可以考慮用this來充當物件，在繼承的方法中，則要考慮是否是同一個物件，慎用this

方法二，同步方法

1） Synchronized 放置在方法的宣告中
2）將操作共享資料的方法宣告為 synchronized ,即此方法為同步方法,能夠保證當其中一個執行緒執行此方法時，其他執行緒在外等待直至此執行緒執行完此方法
3）》同步方法的鎖 this

            public synchronized 返回值型別 方法名(){
                //同步方法體
            }

如果多個執行緒有共享資料的話建議使用實現的方式

例如：

/*
 * 火車購票
 */
class TestTicket5 implements Runnable{
    private int ticket = 20;
    /*
     * 執行緒體
     */
    public void run() {
        while(true) {
            buy();
        }
    }   
    /*
     * 同步方法
     * 同步方法的鎖 為this
     */
    public synchronized void buy() { //買票
        if (this.ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("當前執行緒是：" + Thread.currentThread().getName() + "：" + this.ticket--);
        }       
    }

}
public class TestThread3 {
    public static void main(String[] args) {
        TestTicket5 tt1 = new TestTicket5();
        // 建立執行緒
        Thread t1 = new Thread(tt1);
        Thread t2 = new Thread(tt1);
        Thread t3 = new Thread(tt1);
        // 為執行緒起名
        t1.setName("執行緒1");
        t2.setName("執行緒2");
        t3.setName("執行緒3");
        // 啟動執行緒
        t1.start();
        t2.start();
        t3.start();
    }
}

結果：

當前執行緒是：執行緒1：20
當前執行緒是：執行緒1：19
當前執行緒是：執行緒1：18
當前執行緒是：執行緒2：17
當前執行緒是：執行緒2：16
當前執行緒是：執行緒2：15
當前執行緒是：執行緒2：14
當前執行緒是：執行緒2：13
當前執行緒是：執行緒2：12
當前執行緒是：執行緒2：11
當前執行緒是：執行緒2：10
當前執行緒是：執行緒2：9
當前執行緒是：執行緒2：8
當前執行緒是：執行緒2：7
當前執行緒是：執行緒2：6
當前執行緒是：執行緒2：5
當前執行緒是：執行緒2：4
當前執行緒是：執行緒2：3
當前執行緒是：執行緒3：2
當前執行緒是：執行緒3：1

4）懶漢式執行緒安全問題

    使用同步機制
    對於一般的方法內，使用同步程式碼塊可以使用this
    對於靜態方法而言可以使用當前類本身充當鎖 類名.class

6.死鎖

1）死鎖概念

執行緒雙方都持有對方所需要的鎖，都在等待對方釋放鎖，於是就形成死鎖，也可以理解為：不同的執行緒分別佔用對方需要的同步執行緒不放棄，都在等待對方放棄自己需要的同步資源

2）解決方法：

    儘量減少同步資源的定義
    專門的演算法，原則

例子：

class TestLock1 implements Runnable{
    Object A ;
    Object B;
    public TestLock1(Object a, Object b) {
        super();
        A = a;
        B = b;
    }
    public void run() {
        synchronized (A) {
            try {
                Thread.currentThread().sleep(10);//增加出錯機率
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized(B) {
                System.out.println("這是Test1");
            }
        }       
    }
}

class TestLock2 implements Runnable{
    Object A ;
    Object B;
    public TestLock2(Object a, Object b) {
        A = a;
        B = b;
    }
    public void run() {
        synchronized (B) {
            synchronized(A) {
                System.out.println("這是Test2");
            }
        }       
    }
}

public class DeadLock {
    public static void main(String[] args){
        Object a = new Object();
        Object b = new Object();
        TestLock1 tl1 = new TestLock1(a, b);
        TestLock2 tl2 = new TestLock2(a, b);
        Thread t1 = new Thread(tl1);
        Thread t2 = new Thread(tl2);
        t1.start();
        t2.start(); 
    }
}

結果：

結果為空，程式出現死鎖

7.執行緒間通訊

Java提供了三種方法來進行執行緒間的通訊
wait() 一旦一個執行緒執行到wait(),就釋放當前的鎖
notify() 喚醒wait的一個執行緒
notifyAll() 喚醒wait的多個執行緒
注：上述三種方法只能定義在！！！同步程式碼塊或同步方法！！！中

8.生產者消費者問題

問題：
生產者：沒有生產產品之前通知消費者等待，生產了產品之後，需要馬上通知消費者消費
消費者：消費完成後，通知生產者生產產品

需要用到執行緒同步，與執行緒通訊

例子：

//生產
class Fectory {
    private int goods = 20;

    // 生產產品
    public synchronized void produce() {
        if (this.goods == 20) { // 當庫存滿20時停止生產
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("生產者生產" + (++this.goods));
            notify();// 喚醒消費者消費
        }
    }

    // 消費產品
    public synchronized void consume() {
        if (this.goods < 1) { // 產品庫存小於1時停止消費，等待生產者生產
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("消費者消費" + this.goods--);
            notify();// 喚醒生產者生產
        }
    }
}

// 生產者
class Producer implements Runnable {
    Fectory fe;

    public Producer(Fectory fe) {
        this.fe = fe;
    }

    public void run() {
        while (true) {
            fe.produce();
        }
    }
}

// 消費者
class Consumer implements Runnable {
    Fectory fe;

    public Consumer(Fectory fe) {
        this.fe = fe;
    }

    public void run() {
        while (true) {
            fe.consume();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Fectory fe = new Fectory();
        Producer pro = new Producer(fe);
        Consumer con = new Consumer(fe);
        Thread tp = new Thread(pro);
        Thread tc = new Thread(con);
        tp.start();
        tc.start(); 
    }
}

結果：

消費者消費14
消費者消費13
消費者消費12
消費者消費11
消費者消費10
消費者消費9
消費者消費8
消費者消費7
消費者消費6
消費者消費5
消費者消費4
消費者消費3
消費者消費2
消費者消費1
生產者生產1
生產者生產2
生產者生產3
生產者生產4
生產者生產5
生產者生產6
生產者生產7
生產者生產8
生產者生產9
生產者生產10
生產者生產11
生產者生產12
生產者生產13
生產者生產14
生產者生產15
生產者生產16
生產者生產17
生產者生產18
生產者生產19
生產者生產20
消費者消費20
消費者消費19
消費者消費18
消費者消費17
消費者消費16
消費者消費15
消費者消費14
消費者消費13
消費者消費12
消費者消費11
消費者消費10