快捷導(dǎo)航

java多線程加鎖以及Condition類(lèi)的使用實(shí)例解析

更新時(shí)間：2019年11月27日 10:17:38 作者：喵糧le

這篇文章主要介紹了java多線程加鎖以及Condition類(lèi)的使用實(shí)例解析,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下

看了網(wǎng)上非常多的運(yùn)行代碼,很多都是重復(fù)的再說(shuō)一件事,可能對(duì)于java老鳥(niǎo)來(lái)說(shuō),理解java的多線程是非常容易的事情,但是對(duì)于我這樣的菜鳥(niǎo)來(lái)說(shuō),這個(gè)實(shí)在有點(diǎn)難,可能是我太菜了,網(wǎng)上重復(fù)的陳述對(duì)于我理解這個(gè)問(wèn)題一點(diǎn)幫助都沒(méi)有.所以這里我寫(xiě)下我對(duì)于這個(gè)問(wèn)題的理解,目的是為了防止我忘記.

還是從代碼實(shí)例開(kāi)始講起:

代碼

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Predicate;

public class Main {
  public static void main(String[] args) throws InterruptedException {
    MyBlockingQueue<Integer> queue = new MyBlockingQueue<>(1);
    for (int i = 0; i < 10; i++) {
      int data = i;
      new Thread(() -> {
        try {
          queue.enqueue(data);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }).start();
    }
    System.out.println("1111111");
    for(int i=0;i<10;i++){
      new Thread(() -> {
        try {
          queue.dequeue();
        }catch (InterruptedException e){
          e.printStackTrace();
        }
      }).start();
    }
  }
  public static class MyBlockingQueue<E> {
    int size;//阻塞隊(duì)列最大容量
    ReentrantLock lock = new ReentrantLock(true);
    LinkedList<E> list=new LinkedList<>();//隊(duì)列底層實(shí)現(xiàn)
    Condition notFull = lock.newCondition();//隊(duì)列滿時(shí)的等待條件
    Condition notEmpty = lock.newCondition();//隊(duì)列空時(shí)的等待條件
    public MyBlockingQueue(int size) {
      this.size = size;
    }
    public void enqueue(E e) throws InterruptedException {
      lock.lock();
      try {
        while(list.size() ==size)//隊(duì)列已滿,在notFull條件上等待
          notFull.await();

        list.add(e);//入隊(duì):加入鏈表末尾
        System.out.println("入隊(duì)：" +e);
        notEmpty.signal(); //通知在notEmpty條件上等待的線程
      } finally {
        lock.unlock();
      }
    }
    public E dequeue() throws InterruptedException {
      E e;
      lock.lock();
      try {
        while(list.size() == 0)
          notEmpty.await();
        e = list.removeFirst();//出隊(duì):移除鏈表首元素
        System.out.println("出隊(duì)："+e);
        notFull.signal();//通知在notFull條件上等待的線程
        return e;
      } finally {
        lock.unlock();
      }
    }
  }
}

主函數(shù)啟動(dòng)了20個(gè)線程,前10個(gè)是入隊(duì)的后10個(gè)是出隊(duì)的,我們可以看啊可能輸出結(jié)果,

new Thread(() -> {
try {
queue.enqueue(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();

注意到線程實(shí)現(xiàn),這個(gè)是lambda表達(dá)式實(shí)現(xiàn)Runable接口.

入隊(duì)：0
出隊(duì)：0
入隊(duì)：2
出隊(duì)：2
入隊(duì)：1
出隊(duì)：1
入隊(duì)：3
出隊(duì)：3
入隊(duì)：4
出隊(duì)：4
入隊(duì)：5
出隊(duì)：5
入隊(duì)：6
出隊(duì)：6
入隊(duì)：7
出隊(duì)：7
入隊(duì)：8
出隊(duì)：8
入隊(duì)：9
出隊(duì)：9

可以看到1111111在第一個(gè)出隊(duì)之前,隊(duì)列容量為1,也就是說(shuō)頭10個(gè)入隊(duì)進(jìn)程只有第一個(gè)成功了,其他均被阻塞.

并且出隊(duì)入隊(duì)順序是按照循環(huán)順序的,說(shuō)明鎖是按照請(qǐng)求順序來(lái)獲取的,先到先得,這個(gè)說(shuō)的就是公平鎖的意思,其實(shí)ReentrantLock既可以是公平鎖也可以是非公平鎖,其初始化的時(shí)候,往構(gòu)造函數(shù)里面?zhèn)魅雝rue則為公平鎖,false則為非公平鎖.

至于什么是可重入鎖,可以看看這篇http://www.dbjr.com.cn/article/175192.htm,這個(gè)是可重入鎖的實(shí)例.

其中有一行代碼很奇怪,lock.lock();對(duì)于我這樣的萌新很好奇這個(gè)一行代碼到底發(fā)生了什么,網(wǎng)上很多都是說(shuō)獲得鎖,但是"獲得"這個(gè)實(shí)在難以太不具體,所以我自己想象了一下,感覺(jué)大致上就是這樣的一張圖:

結(jié)合我粗淺的經(jīng)驗(yàn)猜測(cè):jvm只有一個(gè)就緒隊(duì)列,就緒隊(duì)列里面的線程按照隊(duì)列順序使用cpu資源,若不加鎖,那么所有線程都可以按序取得資源,但是由于面向?qū)ο罅?所以不好直接控制就緒隊(duì)列里面線程的入隊(duì)順序,這個(gè)時(shí)候就需要加鎖來(lái)控制線程的運(yùn)行順序來(lái)保證處理邏輯正確.(其實(shí)也不不是那么嚴(yán)格的隊(duì)列,就緒狀態(tài)的線程如果是非公平鎖一般會(huì)隨機(jī)先后的運(yùn)行,說(shuō)是隊(duì)列而已,其實(shí)就是表達(dá)就緒狀態(tài))

結(jié)合代碼的lock()方法,如果有線程進(jìn)入cpu并且調(diào)用lock(),如果該鎖沒(méi)有被其他線程獲取過(guò),那么這個(gè)線程可以使用cpu時(shí)間,如果該鎖已經(jīng)被其他線程獲取了,那么該線程會(huì)給阻塞,進(jìn)入阻塞隊(duì)列, 這樣來(lái)說(shuō)的話,其實(shí)"獲取"這個(gè)詞也沒(méi)什么難以理解的,其實(shí)就是一個(gè)標(biāo)記而已,然后lock()方法其實(shí)就只是判斷當(dāng)前線程是使用cpu時(shí)間,還是進(jìn)入阻塞隊(duì)列而已..

在看看unlock()方法,由上面的圖幫助,其實(shí)這個(gè)也很好理解,其實(shí)就是把阻塞隊(duì)列的隊(duì)首的線程出隊(duì),然后進(jìn)入就緒隊(duì)列而已.

可以猜測(cè),如果運(yùn)行過(guò)程中有多個(gè)鎖實(shí)例,那么就會(huì)有多少個(gè)可能阻塞的線程,那么除了使用用多個(gè)鎖,其實(shí)還有別的方法來(lái)增加阻塞線程,就是使用Condition類(lèi),需要指出的是condition類(lèi)的await()方法,會(huì)阻塞當(dāng)前線程,然后自動(dòng)解除當(dāng)前線程獲取的鎖(這點(diǎn)尤其重要),切換線程,如果其他線程中有喚醒,那么這個(gè)在被喚醒后線程會(huì)從await()的位置繼續(xù)往下運(yùn)行,所以一般要配合while循環(huán)使用,如果某線程被喚醒,那么它對(duì)于它之前獲取的鎖,也將重新獲取,如果此時(shí)該鎖已經(jīng)被另外一個(gè)線程獲取,且還沒(méi)有解鎖,此時(shí)的喚醒就會(huì)出錯(cuò),會(huì)出現(xiàn)莫名其妙的錯(cuò)誤,所以需要設(shè)置一個(gè)volatile變量來(lái)檢測(cè)線程的運(yùn)行狀態(tài),所以await()方法前后都要檢測(cè).

這里提出一道題,來(lái)自leetcode,要求使用condition類(lèi)來(lái)寫(xiě),

題意:

編寫(xiě)一個(gè)可以從 1 到 n 輸出代表這個(gè)數(shù)字的字符串的程序，但是：

如果這個(gè)數(shù)字可以被 3 整除，輸出 "fizz"。

如果這個(gè)數(shù)字可以被 5 整除，輸出 "buzz"。

如果這個(gè)數(shù)字可以同時(shí)被 3 和 5 整除，輸出 "fizzbuzz"。

例如，當(dāng) n = 15，輸出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。

解法:

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

public class Main {
  static void printFizz(int x){
    System.out.printf("%d:Fizz,\n",x);
  }
  static void printBuzz(int x){
    System.out.printf("%d:Buzz,\n",x);
  }
  static void printFizzBuzz(int x){
    System.out.printf("%d:FizzBuzz,\n",x);
  }
  static void printaccpt(int x){
    System.out.printf("%d,\n",x);
  }
  static volatile int now=1;
  static ReentrantLock lock=new ReentrantLock();
  static Condition k1=lock.newCondition();
  public static void test(int n) {

    new Thread(()->{
      while(now<=n){
        lock.lock();
        try{
          while(now%5==0||now%3!=0){
            if(now>n) throw new InterruptedException();
            k1.await();
            if(now>n) throw new InterruptedException();
          }
          printFizz(now);
          now++;
          k1.signalAll();
        } catch (InterruptedException e) {
          break;
          //e.printStackTrace();
        } finally{
          lock.unlock();
        }
      }
      System.out.println("Thread 1 is over");
    }).start();

    new Thread(()->{
      while(now<=n){
        lock.lock();
        try{

          while(now%5!=0||now%3==0) {
            if(now>n) throw new InterruptedException();
            k1.await();
            if(now>n) throw new InterruptedException();
          }
          printBuzz(now);
          now++;
          k1.signalAll();
        } catch (InterruptedException e) {
          break;
          // e.printStackTrace();
        } finally{
          lock.unlock();
        }
      }
      System.out.println("Thread 2 is over");
    }).start();


    new Thread(()->{
      while(now<=n){
        lock.lock();
        try{
          while(now%5!=0||now%3!=0) {
            if(now>n) throw new InterruptedException();
            k1.await();
            if(now>n) throw new InterruptedException();
          }
          printFizzBuzz(now);
          now++;
          k1.signalAll();
        } catch (InterruptedException e) {
          break;
          //Thread.interrupted();
          //e.printStackTrace();
        } finally{
          lock.unlock();
        }
      }
      System.out.println("Thread 3 is over");
    }).start();


    new Thread(()->{
      while(now<=n){
        lock.lock();
        try{
          while(now%5==0||now%3==0) {
            if(now>n) throw new InterruptedException();
            k1.await();
            if(now>n) throw new InterruptedException();
          }
          printaccpt(now);
          now++;
          k1.signalAll();
        }catch (InterruptedException e){
          break;
          //Thread.interrupted();
          //e.printStackTrace();
        }
        finally{
          lock.unlock();
        }
      }
      System.out.println("Thread 4 is over");
    }).start();
  }

  public static void main(String[] args) throws InterruptedException {
    test(30);
  }
}

以上就是本文的全部?jī)?nèi)容，希望對(duì)大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章: