執行緒

在說執行緒之前我們瞭解下什麼是程序.
程序:一個正在執行的程式(獨立執行).
程序和執行緒之間的關係:
一個程序可以只有一個執行緒(單執行緒程式),一個執行緒中也可以有多個執行緒(多執行緒程式).
執行緒:一個執行緒,相當於cpu的執行路徑,一個獨立的單元.
執行緒的作用:大大提升了處理效率.
我們看上面的圖,一個防毒軟體是一個程序,這個程序有三個執行緒.這三個執行緒分別是防毒
軟體的防毒,清理和優化功能,其實每個功能也就是一段程式碼.如果我們同時開啟了這三個
功能,這時候cpu就會給他們對應的每個執行緒一個執行路徑.這裡拿單核的cpu舉例,單核的
cpu一次只能執行一個執行緒,所以當執行第一個執行緒的時候其他兩個執行緒都在等待,但是這
裡的執行執行緒不是一次性把這個執行緒的程式碼全部執行完,而是在三個執行緒之間來回切換執行
.但是每個執行緒又可以設定優先順序,優先順序高的可以讓cpu多執行那個執行緒一會,這也叫搶奪
資源.
標準的單執行緒例子:
public
 
 static void main(String[] args) {
    /*
     * 標準的單執行緒程式
     * 絕對安全 程式由上至下依次執行 但是 效率不高
     * 
     */
    // 新增
    add();
    // 刪除
    remove();
    System.out.println("程式執行完畢");
}
public static void add() {
    for (int i = 0; i < 100; i++) {
        System.out.println(i);
    }
}
public static void
 
 remove() {
    System.out.println("刪除");
}
解析:程式碼從頭執行到尾,依次執行,就是標準的單執行緒.
public static void main(String[] args) {
    // Exception in thread "main" 異常出現在 執行緒main中
    System.out.println(10 / 0);
    add();
    System.out.println("程式完成");
}

public static void add() {
    for (int i = 0; i < 100; i++) {
        System.out
 
.println(i);
    }
}
之前我們說算數異常的時候,都是隻看右邊by zero,現在我們看左邊.
Exception in thread "main" java.lang.ArithmeticException: / by zero
thread就是執行緒,我們的main函式也是主執行緒.那麼執行緒是如何開啟的呢?
JVM呼叫main方法 ---> 找作業系統(cpu) ---> 開啟一個執行路徑
開啟一個叫main執行路徑,main就是一個執行緒,又叫主執行緒.
知道了什麼是執行緒後,我們如何去建立一個執行緒呢?
第一種方法:
寫一個類去繼承Thread類
public static void main(String[] args) {
    // 建立一個執行緒
    SubThread subThread = new SubThread("哈哈");
    // 如果你直接呼叫run方法 相當於 就調了一個普通成員方法
//      subThread.run();
    // 開啟執行緒
    // 注意:直接呼叫run方法不能開啟執行緒 需要呼叫start方法開啟執行緒
    subThread.start();
    for (int i = 0; i < 50; i++) {
        System.out.println("--main--" + i);
    }
    // 獲取當前執行的執行緒物件方法 靜態方法
    Thread currentThread = Thread.currentThread();
    // 獲取主執行緒的名字
    String name = currentThread.getName();
    System.out.println("****" + name);
}
class SubThread extends Thread {
    // 重寫run方法
    @Override
    public void run() {
        // Exception in thread "Thread-0"
    }   
}
注意:繼承Thread類後一定要重寫run方法,因為例項化物件的時候,開啟執行緒系統就會調
用自動幫我們run方法,如果不重新,那就沒什麼意義.千萬不要使用物件取調run方法,因
為那樣呼叫run方法只是一個普通的方法,切記系統會幫我們呼叫.開啟執行緒用物件.start
第二種方法:
寫一個類去實現Runnable介面,然後例項化一個執行緒物件,把實現類物件傳入執行緒的構造
方法裡.
// 實現Runnable介面建立執行緒物件
// 介面中run方法是個抽象方法
public class Demo {
    public static void main(String[] args) {
        // 建立執行緒
        Thread thread = new Thread(new RunnableImpl(), "哈哈");
        // 開啟執行緒
        thread.start();
    }
}
class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " RunnableImpl");
    }
}
方法介紹:
當前執行的執行緒物件方法 靜態方法
Thread currentThread = Thread.currentThread();
獲取當前執行緒的名字
String name = currentThread.getName();
給執行緒設定名字
第一種:構造物件的時候把名字傳入構造方法裡
第二種:呼叫執行緒物件.setName(name);
注意:子類裡面最好不要定義name為成員變數,因為父類裡面的執行緒名就是用的name,而且
父類的get/set方法用final修飾了,如果子類還是要用name為成員變數的話就必須把子
類裡自動生成的get/set的標準寫法,換成一個新的方法名,不然編譯就會報錯.還有為什
麼主執行緒迴圈列印1-10並且主執行緒開啟了一個子執行緒(run方法裡也是列印1-10),結果看
起來是亂的,因為執行緒的執行順序就是cpu支線到誰就呼叫該執行緒的方法,所以主執行緒和字
執行緒就是隨機被執行的.
知識點: 
1.建立一個執行緒 相當於cpu開闢了一個獨立的執行路徑
2.每個執行路徑都是一個獨立的空間
3.建立一個執行緒 該執行緒就會擁有一個獨立棧空間

執行緒的六種狀態

執行緒的六種狀態:
1.新建狀態(例項化執行緒物件的時候)
2.執行狀態(呼叫start方法)
3.受阻塞狀態(等待cpu的執行資源)
4.休眠狀態(呼叫了sleep(時間)方法)
5.等待狀態(呼叫了wait()方法)
6.死亡狀態(run()方法執行完畢)
狀態圖沒必要死記,只要記住六種狀態然後就可以互相推理出來他們之間的關係.
建立執行緒的第三種方法:
使用匿名內部類方法,它的作用就相當於建立一個該子類的物件.
公式:
new 父類名或者介面名(){
    重寫父類的方法
};
這裡例項化出來的物件是子類的物件.
Thread t1 = new Thread() {
    @Override
    public void run() {
        System.out.println("我是建立執行緒方式1");
    }
};
t1.start();
Thread t2 = new Thread(new Runnable() {

    @Override
    public void run() {
        System.out.println("我是建立執行緒方式2");
    }
});
t2.start();
解析:如果只是new出來的話是沒有物件名的,而且只能呼叫一次方法,再繼續呼叫其他的方
法就得重新new一個出來,但是在類裡面使用匿名內部類的方式也是可以建立物件名出來的.
執行緒休眠問題:
讓執行緒休眠的方法是sleep(這裡填時間) 單位毫秒,sleep是過載方法,不一樣的引數時
間單位也不一樣.
class SleepThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            // 休眠一秒
            // 如果子執行緒中 出現異常 只能try...catch處理
            /*
             * Thread類 是Runnable介面的 實現類
             * 重寫介面中的 run方法
             * 該方法 沒有丟擲異常
             * 所以 所以的Runnable介面實現類 (包括Thread類)
             * 都不能在run方法中 丟擲異常 只能處理
             */
            try {
                super.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
注意:使用sleep方法會有異常,但是我們不能丟擲異常,是因為父類的run方法壓根就沒拋
出異常,所以子類的方法就更沒辦法拋了,那就只有使用try..catch方法.為什麼會有異
常呢,因為前說了執行緒有六種狀態,萬一執行睡眠前面的程式碼都正常,剛好執行到睡眠那一
句前面執行緒突然中斷或者阻塞之類的,那就沒辦法執行到睡眠.

鎖

一說到鎖就會提到一個經典問題,那就是賣票.
每個執行緒就像一個賣票的app,可以是去火車站買,可以用12306,可以用飛豬...
我們現在建立三個執行緒,去賣50張票.
class ThreadSell extends Thread {
    private int number = 100;
    @Override
    public void run() {
        while (number > 0) {
            System.out.println(Thread.currentThread().getName() + "剩餘" + --number + "張");
        }
    }
}
public static void main(String[] args) {
        ThreadSP t1 = new ThreadSP();
        ThreadSP t2 = new ThreadSP();
        ThreadSP t3 = new ThreadSP();
        t1.start();
        t2.start();
        t3.start();
}
然後看執行結果就會發現,多賣了一點票.這是為什麼呢?
前面也說了,每個執行緒都有自己獨立的棧記憶體,所以三個執行緒之間互不影響.但是資料只有
一份,比如說現在開始賣第一張票,因為三個執行緒互不干擾,有可能三個同時訪問到資料,然
後cpu開啟了第一個執行緒的執行路徑,其他兩個執行緒則在等待,第一個執行緒執行完再自減,但
是這時候其他兩個執行緒的num還是50,所以這就是出現問題的根源.那麼我們怎麼解決呢.
這裡我們需要用到鎖,鎖的關鍵字是synchronized,這裡我們要怎麼寫呢?
程式碼如下:
/*
 * 同步鎖(也叫同步程式碼塊)
 * 鎖可以是任意物件 要保證 鎖的唯一 三個執行緒都使用的時同一把鎖
 * synchronized(物件鎖){
 *  
 * }
 */
class Tickets implements Runnable {
    // 宣告50張票 保證票是共享資料 只New一次該類物件
    private int tickets = 50;
    // 建立了物件鎖 保證唯一
    private Object obj = new Object();
    // 賣票方法
    @Override
    public void run() {
        while (true) {
            // 鎖只要保證是物件和唯一就可以 填this可以
            synchronized (this) {
                // 操作的共享資料
                if (tickets > 0) {
                    // 列印之前讓執行緒休眠一會
                    try { 
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // 有票就賣
                    System.out.println(Thread.currentThread().getName() 
                            + "--" + tickets);
                    // 減少一張
                    tickets--;
                }else {
                    // 沒票 結束迴圈
                    break;
                }
            }
            // 讓執行緒讓出cpu的資源
            Thread.yield();
        }
    }
}
public static void main(String[] args) {
    Tickets t = new Tickets();
    Thread t1 = new Thread(t);
    Thread t2 = new Thread(t);
    Thread t3 = new Thread(t);
    t1.start();
    t2.start();
    t3.start();
}
同步鎖規則:
1.執行緒 遇到鎖 就進程式碼塊(並且攜帶鎖)
2.當執行緒 執行完程式碼塊中的程式碼 把鎖返還
3.執行緒沒有遇到鎖 會在同步程式碼塊外等著 遇到鎖才能進
在這裡,鎖的物件只能是唯一的,上面就例項化出了一個物件,所以符合它的規定.
synchronized (obj)和synchronized (this)
因為在例項化物件的時候,Tickets類裡就例項化了一個Object物件,這個物件不會改變.
為什麼寫this也行呢?因為this表示本類物件,我們本來就只例項化了一次,所以只有一個
本類物件.
模擬死鎖的過程:
/*
 * 模擬執行緒死鎖
 */
public class Demo {
    public static void main(String[] args) {
        DieLockRunnable dieLockRunnable = new DieLockRunnable();
        Thread t1 = new Thread(dieLockRunnable);
        Thread t2 = new Thread(dieLockRunnable);
        t1.start();
        t2.start();
    }
}
// A鎖
class LockA {
    // 定義一個常量  作為鎖物件 不能修改(也不能建立)
    public static final LockA LOCK_A = new LockA();
    // 私有構造方法
    private LockA() {}
}
// B鎖
class LockB {
    // 定義一個常量  作為鎖物件 不能修改(也不能建立)
    public static final LockB LOCK_B = new LockB();
    // 私有構造方法
    private LockB() {}
}
// 執行緒
class DieLockRunnable implements Runnable{
    private boolean isTrue = true;
    @Override
    public void run() {
        while (true) {
            if (isTrue) {
                // A鎖到B鎖
                synchronized (LockA.LOCK_A) {
                    System.out.println("第一次先A");
                    synchronized (LockB.LOCK_B) {
                        System.out.println("第一次後B");
                    }
                }
            } else {
                // B鎖到A鎖
                synchronized (LockB.LOCK_B) {
                    System.out.println("第二次先B");
                    synchronized (LockA.LOCK_A) {
                        System.out.println("第二次後A");
                    }
                }
            }
            // 修改標記
            isTrue = !isTrue;
        }
    }
}
Lock鎖
我們看API裡,Lock是一個介面,我們要使用它,要麼匿名內部類去實現,要是就實現介面.
我們去實現它的子介面:
class Tickets3 implements Runnable {
    private int tickets = 50;
    // 宣告鎖物件
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            // 加鎖
            lock.lock();
            try {
                // 鎖住操作共享資料的程式碼
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + 
                                "---" + "剩餘" + tickets + "張票");
                    tickets--;
                }else {
                    break;
                }
            } finally {
                // 解鎖
                lock.unlock();
            }
            Thread.yield();
        }
    }   
}
為什麼要使用try...finally,博主也不知道,人家API裡面就是這麼給的示範寫法,我們
就只能照著人家寫的規則來.使用Lock加鎖就物件.lock(),解鎖就lock.unlock();