Java併發程式設計：執行緒和鎖的使用與解析

執行緒的使用

　 新建執行緒

　　新建一個執行緒有兩種方法：繼承Thread類，然後重寫run方法；實現Runnable介面，然後實現run方法。實際上Thread類也是實現的Runnable介面，再加上類只能單繼承，所以推薦使用Runnable介面。示例如下：

 

class Demo1 implements Runnable{
    @Override
    public void run() {
        //新建執行緒需要執行的邏輯
    }
}

 

class Demo2 extends Thread{
    @Override
    public void run() {
        //新建執行緒需要執行的邏輯
    }
}

　　對於Thread類，當然可以使用匿名內部類來簡化寫法：

Thread thread=new Thread(){
    public void run(){
        //新建執行緒需要執行的邏輯
    }
};
//Lambda表示式簡化後
Thread thread=new Thread(()->{
    //需要執行的邏輯
});

新建完一個執行緒後，就可以用物件例項來啟動執行緒，啟動後就會執行我們重寫後的run方法：

thread.start();

　　此外，Thread類有個非常重要的構造方法：

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

　　可見，傳入的是一個Runnable型別的引數。為什麼需要這個建構函式？因為Runnable介面只有一個run方法，如果我們直接例項化實現了這個介面的類，然後呼叫run方法，其實就和普通的類沒有區別，並沒有另外一個執行緒去執行run方法。說白了，Runnable並不是新建了一個執行緒，而只是執行緒裡面執行任務的一種型別。在Java併發程式設計裡，我們總是說的任務，很多時候就是Runnable型別的。所以我們還是需要把實現了Runnable介面的類的例項傳入Thread的建構函式，然後通過start方法去呼叫Runnable的run方法。

//新建一個任務(Demo1實現了Runnable介面)
Demo1 task=new Demo1;
//新建一個執行緒並傳入需要執行的任務
Thread thread=new Thread(task);
//啟動執行緒執行任務
thread.start();

　 執行緒的其他方法

　　熟悉了執行緒的建立，再簡單瞭解一下操作執行緒的其他方法。

　　stop方法：作用是終止執行緒，但不推薦使用，因為它是強制結束執行緒，不管執行緒執行到了哪一步，很容易造成錯誤資料，引起資料不一致的問題。

　　interrupt方法：作用和stop類似，但是並不會那麼粗魯的終止執行緒，如果只呼叫這一個方法並不會中斷執行緒，它還需要配合一個方法使用：

class Demo implements Runnable {
    @Override
    public void run() {
        //通過isInterrupted方法判斷當前執行緒是否需要停止，不需要停止就執行邏輯程式碼
        while (!Thread.currentThread().isInterrupted()){
            //邏輯
        }
    }
}
public class Use {
    public static void main(String[] args) throws InterruptedException {
        Demo task = new Demo ();
        Thread thread=new Thread(task);
        thread.start();
        //通知thread可以終止了
        thread.interrupt();
    }
}

　　wait方法和notify方法：這兩個方法放在一起說，是因為它們需要配合使用。簡單提一下synchronized ,這個會在在鎖裡面講。synchronized大概的作用就是：程式碼塊裡的程式碼，同時只能由一個執行緒去執行，如何確保只有一個執行緒去執行？誰擁有鎖誰就有資格執行。任何物件都可以呼叫wait方法，如obj.wait，它的意思就是讓當前執行緒在obj上等待並釋放當前執行緒佔用的鎖。obj.notify就是喚醒在obj上等待的執行緒並重新嘗試獲取鎖。下面演示一下簡單的使用：

public class Use {
    //一定要確保等待和喚醒是同一個物件，用類鎖也可以，至於什麼是類鎖可以看後面synchronized部分
    static Object object=new Object();
    static int i = 0;
    static class Demo1 implements Runnable {
        @Override
        public void run() {
            synchronized (object){
                for(int j=0;j<10000;j++){
                    i++;
                    if(i==5000){
                        //1.因為t1先啟動並進入同步程式碼塊，所以首先輸出5000
                        System.out.println();
                        try {
                            //釋放鎖並等待
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                //3.被喚醒後接著執行完剩餘的程式碼，輸出20000
                System.out.println(i);
            }
        }
    }
    static class Demo2 implements Runnable{
        @Override
        public void run() {
            synchronized (object){
                for(int j=0;j<10000;j++){
                    i++;
                }
                //2.獲取到t1釋放的鎖，執行完程式碼後輸出15000並喚醒object上等待的執行緒
                System.out.println(i);
                object.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1=new Thread(task1);
        Thread thread2=new Thread(task2);
        thread1.start();
        thread2.start();
    }
}

　　需要注意的是，如果有多個執行緒在obj等待，只執行一次obj.notify的話，它是隨機從obj等待列表中選擇一個執行緒喚醒的，如果要喚醒所有等待執行緒，可以使用obj.notifyAll。不管wait、notify還是notifyAll只能在synchronized程式碼塊中使用，否則會報IllegalMonitorStateException異常。Java之所以這麼規定，是確保不會發生Lost Wake Up問題，也就是喚醒丟失。上面那個例子中使用了同步程式碼塊，所以不會發生這種問題。試想一種情況，如果沒有synchronized確保執行緒是有秩序執行的，當t2執行緒先喚醒了object上的物件，t1執行緒後暫停的，那麼t1是不是就永遠會暫停下去，t2的notify相當於丟失了，這就是Lost wake up。

　　join方法：作用是讓指定執行緒加入當前執行緒。為了節約篇幅還是以interrupt方法的程式碼為例，如果在main方法裡呼叫thread.join()，那麼主執行緒就會等待thread執行緒執行完才接著執行。其實這就和單執行緒的效果差不多了。如果有時候thread執行緒執行時間太長，為了不影響其他執行緒，我們可以在join方法裡傳入一個時間，單位是毫秒，當過了這個時間不管thread執行緒有沒有執行完，主執行緒都會接著執行。join方法其實是通過wait方法實現的，注意這個wait是被加入執行緒等待，而不是加入的執行緒等待。貼一下原始碼，邏輯很簡單就不復述了，如果join不傳入引數，millis預設就是0：

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

　　yield方法：這個方法會讓出當前執行緒的CPU，讓出後還會接著去爭奪，但是還能不能爭奪到就不一定了。一般優先順序比較低的執行緒，為了節約資源可以適當呼叫這個方法。

 

執行緒安全

　　如何保證執行緒安全？無非就是鎖的爭奪。誰擁有了鎖，誰才有資格執行。為什麼只讓一個執行緒執行程式碼？這就與Java的記憶體模型有關了。不瞭解的可以看其他資料，也可以看看我的另外一篇部落格：https://www.cnblogs.com/lbhym/p/12458990.html，最後一節就是講Java記憶體模型的。簡單的說：執行緒共享的資源是放在一個共享記憶體區域的。當執行緒A去操作一個共享變數時，它會先把這個變數拷貝到自己私有的記憶體空間，然後進行操作，最後把操作後的值賦值到共享記憶體中的變數。如果在賦值之前另外一個執行緒B剛剛更新了這個值，那麼執行緒A的操作就把執行緒B的操作給覆蓋了，而執行緒B渾然不知，接著執行它的邏輯，這就造成了資料不一致的情況。所以我們必須加上一把鎖，確保同一時間只能由一個執行緒來修改這個變數。

　　關鍵字synchronized

　　關鍵字synchronized的作用前面已經提到過了，下面給個簡單的示例：

class Demo implements Runnable {
    static int i = 0;
    @Override
    public void run() {
        //小括號中的Demo.class就是鎖，大括號內的程式碼同時只能由一個執行緒執行
       synchronized (Demo.class){
           for(int j=0;j<10000;j++) {
               i++;
           }
       }
    }

}
public class Use {
    public static void main(String[] args) throws InterruptedException {
        Demo task = new Demo();
        Thread thread1=new Thread(task);
        Thread thread2=new Thread(task);
        thread1.start();
        thread2.start();
        //讓兩個執行緒加入主執行緒，這樣就可以輸出執行後的i了
        thread1.join();
        thread2.join();
        System.out.println(Demo.i);//輸出20000，如果去掉同步程式碼塊，i絕對小於20000
    }
}

　　其實這個關鍵字的作用很好理解，關鍵在於，小括號裡面有什麼實際意義，它與Lock有什麼區別？

　　首先synchronized和Lock都是Java裡面的鎖機制，前者用起來更加方便，後者功能更多。方便在哪？進入程式碼塊前自動獲取鎖，如果鎖已經被佔，則會等待。執行完同步程式碼塊中的內容，自動釋放鎖。而Lock需要手動加鎖解鎖，接下來會講。

　　接著說說synchronized具體用法，小括號裡就是鎖物件。有一點需要注意，synchronized鎖的是物件，而不是裡面的程式碼，誰擁有指定的鎖誰就能執行裡面的程式碼。明白這一點有助於理解下面的內容。

　　synchronized的鎖分為類鎖和物件鎖。它們的區別就是作用域的不同。

　　首先說說物件鎖怎麼用以及它的特點：

//物件鎖：
synchronized(this){...}
synchronized(類的例項){...}
//修飾在void前也是物件鎖
public synchronized void run(){...}

　　如果synchronized裡指定的是物件鎖，那麼在建立task時，不同的例項物件就是不同的鎖。大家可以在上面示例程式碼的基礎上，再用Demo類例項化一個task2，然後用thread去執行它，接著把synchronized小括號裡的鎖換成this，也就是物件鎖，會發現輸出的i小於20000。因為task和task2完全就是不同的鎖，兩個執行緒並不衝突，這就是為什麼上面強調，鎖的是物件，而不是裡面的程式碼。

　　再說說類鎖的用法和特點：

//類鎖
synchronized(類名.class){...}
//修飾在靜態方法前也是類鎖,run方法裡直接呼叫handler就行
private synchronized static void handler(){...}

　　上面的示例程式碼就是一個類鎖，即使例項化兩個不同的物件，提交給兩個執行緒執行後，輸出結果肯定是20000，也就是說它們是同步的。

　　最後說一點，同一個類中，類鎖和物件鎖依舊是不同的鎖，它們之間互不干擾，不是同步的。舉個例子：

class Demo implements Runnable {
    static int i = 0;
    @Override
    public void run() {
          run2();
          run3();
    }
    //類鎖
    private synchronized static void run2(){
        for(int j=0;j<10000;j++) {
            i++;
        }
    }
    //物件鎖
    private synchronized void run3(){
        for(int j=0;j<10000;j++) {
            i++;
        }
    }
}

　　main方法就不貼了，記得例項化一個task2給thread2執行。最後的輸出結果肯定小於40000，如果把run3改成靜態方法，也就是變成類鎖，輸出結果就是40000了。

　  介面Lock

　　Lock介面下提供了一套功能更完整的鎖機制。如果專案中執行緒的競爭並不激烈，使用synchronized完全足夠，如果競爭很激烈，還需要其他一些功能，這時候就可以嘗試一下Lock提供的鎖了。

　　ReentrantLock：可重入鎖

　　簡單的示例如下，說明也在註釋當中:

class ReenterLock implements Runnable {
    //可重入鎖，意思是：在同一個執行緒中，可以對lock多次加鎖，當然也必須解鎖對應次數
    //那麼Lock下的鎖是類鎖還是物件鎖，取決於鎖物件是類變數還是普通的全域性變數，加上static就是類鎖，反之就是物件鎖
    static ReentrantLock lock = new ReentrantLock();
    static int i = 0;
    @Override
    public void run() {
        lock.lock();
        for (int j=0;j<10000;j++){
            i++;
        }
        lock.unlock();
    }
}
public class 可重入鎖 {
    public static void main(String[] args) throws InterruptedException {
        ReenterLock task = new ReenterLock();
        Thread thread1=new Thread(task);
        Thread thread2=new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(ReenterLock.i);
    }
}

　　可重入鎖除了以上加鎖、解鎖的基本功能外，還有其他一些功能：

　　lockInterruptibly方法和interrupt方法：後者線上程中已經出現過一次了，雖然名字一樣，功能也差不多，但是作用物件不一樣。如果我們的執行緒在加鎖也就是獲取鎖時，用的是lockInterruptibly方法，如果在等待一段時間後，還沒獲取到鎖，那麼就可以通過interrupt方法通知這個執行緒不用等了。這兩個方法配合使用，在設定合理的等待時間後，可以避免死鎖的發生。但需要注意，被通知放棄獲取鎖的執行緒會釋放自己的資源，結束執行任務。

　　tryLock方法：除了上面那種外部通知放棄獲取鎖的方法外，還有一種限時等待的方法，tryLock有兩個引數，第一個是時間，第二個是時間型別。如果不傳入任何引數，獲取到鎖直接返回true，沒獲取到直接返回false。對的，tryLock和普通的lock方法不同，它返回的是Boolean型別，所以一般需要配合if判斷使用：

@Override
public void run() {
    try {
        if (lock.tryLock(10, TimeUnit.SECONDS)) {
            //邏輯程式碼
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

　　公平鎖和非公平鎖：公平鎖的分配是公平的，先到先得。非公平鎖則是隨機分配鎖的，你先等待的不一定能先獲取到鎖。具體的是在ReenterLock建構函式中進行設定：

//建構函式傳入true就是公平鎖，預設情況下是非公平鎖
static ReentrantLock lock = new ReentrantLock(true);

　　預設情況下采用非公平鎖，是因為公平鎖需要維護一個有序佇列，效能相較於非公平鎖是非常低的。

 

　　Condition：可重入鎖的搭檔

　　在synchronized程式碼塊中，可以使用wait方法讓當前執行緒釋放鎖並等待，然後通過notify方法喚醒執行緒並嘗試重新獲取鎖。但是這兩個方法是作用在synchronized中的，前面也說過了。在可重入鎖也有類似的功能，下面舉個簡單的例子，會發現和synchronized中的wait和notify差不都：

public class Use {
    static ReentrantLock lock = new ReentrantLock();
    //建立的lock的condition物件
    static Condition condition = lock.newCondition();
    static int i = 0;
    static class Demo1 implements Runnable {
        @Override
        public void run() {
            //t1先進來加鎖(遇到一次特殊情況，t2後啟動的反而先獲取到鎖了)
            lock.lock();
            for (int j = 0; j < 10000; j++) {
                i++;
                if (i == 5000) {
                    //1.輸出5000
                    System.out.println(i);
                    try {
                        //釋放鎖並等待
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            //被喚醒後接著執行完剩下的程式碼，並輸出20000
            System.out.println(i);
            lock.unlock();
        }
    }
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            //獲取鎖
            lock.lock();
            for (int j = 0; j < 10000; j++) {
                i++;
            }
            System.out.println(i);
            //2.執行完後輸出15000，並喚醒等待的執行緒
            condition.signal();
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
    }
}

　　await方法會使當前執行緒等待，同時釋放當前鎖，當其他執行緒中使用signal()方法或者signalAll()方法時，執行緒會重新獲得鎖並繼續執行。或者當執行緒被中斷時，也能跳出等待。這和Object.wait()方法相似。

　　awaitUninterruptibly方法與await方法基本相同，但是它並不會在等待過程中響應中斷。

　　singal方法用於喚醒一個在等待中的執行緒，singalAll方法會喚醒所有在等待中的執行緒。這和Obejct.notify()方法很類似。

 

　　Semaphore：允許多個執行緒同時訪問

　　前面提到的可重入鎖和同步程式碼塊一次只能讓一個執行緒進入，而Semaphore可以指定多個執行緒，同時訪問一個資源。

public class Use {
    static int i = 0;
    //一次允許兩個執行緒進入
    static Semaphore sema = new Semaphore(2);
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            try {
                //如果有多餘的名額就允許一個執行緒進入
                sema.acquire();
                for(int j=0;j<10000;j++){
                    i++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                //當前執行緒執行完程式碼並釋放一個名額
                sema.release();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task2);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);//輸出小於20000，說明同時有兩個執行緒進去了，互相干擾了。
    }
}

　　

　　ReadWriteLock：讀寫鎖

　　很多時候執行緒只是執行讀操作，並不會互相干擾，其實這個時候並不需要執行緒之間相互排斥。在資料庫裡面讀寫鎖是比較常見的，在Java中，它們的邏輯其實是一樣的。只有讀和讀不會阻塞，有寫操作必然阻塞。

程式碼篇幅太多了，就不再演示邏輯程式碼了，下面是讀寫鎖的建立程式碼：

static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
//讀鎖
static Lock readLock=readWriteLock.readLock();
//寫鎖
static Lock writLock=readWriteLock.writeLock();

　　

　　CountDownLatch：倒計數器

　　一個實用的多執行緒工具類，說倒計數器可能有點不明白，其實就是等來指定數量的執行緒執行完後才執行接下來的程式碼，看示例更清楚：

public class Use {
    //需要兩個執行緒執行完任務
    static CountDownLatch count = new CountDownLatch(2);
    static int i=0;
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            synchronized (Use.class) {
                for (int j = 0; j < 10000; j++) {
                    i++;
                }
                //當前執行緒執行完任務，計數器+1
                count.countDown();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task2);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
        //等待指定數量的執行緒都執行完任務後才接著執行，相當於阻塞了當前的主執行緒，從而實現了join的功能
        count.await();
        System.out.println(i);//輸出20000
    }
}