本篇內容介紹了“java多線程加鎖以及Condition類的使用實例”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

站在用戶的角度思考問題，與客戶深入溝通，找到羅源網(wǎng)站設計與羅源網(wǎng)站推廣的解決方案，憑借多年的經(jīng)驗，讓設計與互聯(lián)網(wǎng)技術結合，創(chuàng)造個性化、用戶體驗好的作品，建站類型包括：做網(wǎng)站、成都網(wǎng)站建設、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣、域名申請、雅安服務器托管、企業(yè)郵箱。業(yè)務覆蓋羅源地區(qū)。

代碼

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;//阻塞隊列較大容量    ReentrantLock lock = new ReentrantLock(true);    LinkedList<E> list=new LinkedList<>();//隊列底層實現(xiàn)    Condition notFull = lock.newCondition();//隊列滿時的等待條件    Condition notEmpty = lock.newCondition();//隊列空時的等待條件    public MyBlockingQueue(int size) {      this.size = size;    }    public void enqueue(E e) throws InterruptedException {      lock.lock();      try {        while(list.size() ==size)//隊列已滿,在notFull條件上等待          notFull.await();        list.add(e);//入隊:加入鏈表末尾        System.out.println("入隊：" +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();//出隊:移除鏈表首元素        System.out.println("出隊："+e);        notFull.signal();//通知在notFull條件上等待的線程        return e;      } finally {        lock.unlock();      }    }  }}

主函數(shù)啟動了20個線程,前10個是入隊的后10個是出隊的,我們可以看啊可能輸出結果,

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

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

入隊：0出隊：0入隊：2出隊：2入隊：1出隊：1入隊：3出隊：3入隊：4出隊：4入隊：5出隊：5入隊：6出隊：6入隊：7出隊：7入隊：8出隊：8入隊：9出隊：9

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

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

至于什么是可重入鎖,可以看看這篇/tupian/20230522/pp結合代碼的lock()方法,如果有線程進入cpu并且調用lock(),如果該鎖沒有被其他線程獲取過,那么這個線程可以使用cpu時間,如果該鎖已經(jīng)被其他線程獲取了,那么該線程會給阻塞,進入阻塞隊列, 這樣來說的話,其實"獲取"這個詞也沒什么難以理解的,其實就是一個標記而已,然后lock()方法其實就只是判斷當前線程是使用cpu時間,還是進入阻塞隊列而已..

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

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

這里提出一道題,來自leetcode,要求使用condition類來寫,

題意:

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

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

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

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

例如，當 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);  }}

“java多線程加鎖以及Condition類的使用實例”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關的知識可以關注創(chuàng)新互聯(lián)網(wǎng)站，小編將為大家輸出更多高質量的實用文章！

分享題目：java多線程加鎖以及Condition類的使用實例-創(chuàng)新互聯(lián)
當前網(wǎng)址：http://www.chinadenli.net/article14/dppoge.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供ChatGPT、App開發(fā)、關鍵詞優(yōu)化、網(wǎng)站策劃、網(wǎng)站建設、自適應網(wǎng)站

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)