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

耶low發表於2020-05-18

執行緒的使用

  新建執行緒

  新建一個執行緒有兩種方法:繼承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是不是就永遠會暫停下去,t2notify相當於丟失了,這就是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。因為tasktask2完全就是不同的鎖,兩個執行緒並不衝突,這就是為什麼上面強調,鎖的是物件,而不是裡面的程式碼。

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

//類鎖
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
    }
}

 

相關文章