java多線程加鎖以及Condition類的使用實(shí)例解析
這篇文章主要介紹了java多線程加鎖以及Condition類的使用實(shí)例解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下
看了網(wǎng)上非常多的運(yùn)行代碼,很多都是重復(fù)的再說一件事,可能對于java老鳥來說,理解java的多線程是非常容易的事情,但是對于我這樣的菜鳥來說,這個實(shí)在有點(diǎn)難,可能是我太菜了,網(wǎng)上重復(fù)的陳述對于我理解這個問題一點(diǎn)幫助都沒有.所以這里我寫下我對于這個問題的理解,目的是為了防止我忘記.
還是從代碼實(shí)例開始講起:
代碼
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<>();//隊列底層實(shí)現(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個是出隊的,我們可以看啊可能輸出結(jié)果,
new Thread(() -> {
try {
queue.enqueue(data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
注意到線程實(shí)現(xiàn),這個是lambda表達(dá)式實(shí)現(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個入隊進(jìn)程只有第一個成功了,其他均被阻塞.
并且出隊入隊順序是按照循環(huán)順序的,說明鎖是按照請求順序來獲取的,先到先得,這個說的就是公平鎖的意思,其實(shí)ReentrantLock既可以是公平鎖也可以是非公平鎖,其初始化的時候,往構(gòu)造函數(shù)里面?zhèn)魅雝rue則為公平鎖,false則為非公平鎖.
至于什么是可重入鎖,可以看看這篇http://www.dbjr.com.cn/article/175192.htm,這個是可重入鎖的實(shí)例.
其中有一行代碼很奇怪,lock.lock();對于我這樣的萌新很好奇這個一行代碼到底發(fā)生了什么,網(wǎng)上很多都是說獲得鎖,但是"獲得"這個實(shí)在難以太不具體,所以我自己想象了一下,感覺大致上就是這樣的一張圖:
結(jié)合我粗淺的經(jīng)驗(yàn)猜測:jvm只有一個就緒隊列,就緒隊列里面的線程按照隊列順序使用cpu資源,若不加鎖,那么所有線程都可以按序取得資源,但是由于面向?qū)ο罅?所以不好直接控制就緒隊列里面線程的入隊順序,這個時候就需要加鎖來控制線程的運(yùn)行順序來保證處理邏輯正確.(其實(shí)也不不是那么嚴(yán)格的隊列,就緒狀態(tài)的線程如果是非公平鎖一般會隨機(jī)先后的運(yùn)行,說是隊列而已,其實(shí)就是表達(dá)就緒狀態(tài))
結(jié)合代碼的lock()方法,如果有線程進(jìn)入cpu并且調(diào)用lock(),如果該鎖沒有被其他線程獲取過,那么這個線程可以使用cpu時間,如果該鎖已經(jīng)被其他線程獲取了,那么該線程會給阻塞,進(jìn)入阻塞隊列, 這樣來說的話,其實(shí)"獲取"這個詞也沒什么難以理解的,其實(shí)就是一個標(biāo)記而已,然后lock()方法其實(shí)就只是判斷當(dāng)前線程是使用cpu時間,還是進(jìn)入阻塞隊列而已..
在看看unlock()方法,由上面的圖幫助,其實(shí)這個也很好理解,其實(shí)就是把阻塞隊列的隊首的線程出隊,然后進(jìn)入就緒隊列而已.
可以猜測,如果運(yùn)行過程中有多個鎖實(shí)例,那么就會有多少個可能阻塞的線程,那么除了使用用多個鎖,其實(shí)還有別的方法來增加阻塞線程,就是使用Condition類,需要指出的是condition類的await()方法,會阻塞當(dāng)前線程,然后自動解除當(dāng)前線程獲取的鎖(這點(diǎn)尤其重要),切換線程,如果其他線程中有喚醒,那么這個在被喚醒后線程會從await()的位置繼續(xù)往下運(yùn)行,所以一般要配合while循環(huán)使用,如果某線程被喚醒,那么它對于它之前獲取的鎖,也將重新獲取,如果此時該鎖已經(jīng)被另外一個線程獲取,且還沒有解鎖,此時的喚醒就會出錯,會出現(xiàn)莫名其妙的錯誤,所以需要設(shè)置一個volatile變量來檢測線程的運(yùn)行狀態(tài),所以await()方法前后都要檢測.
這里提出一道題,來自leetcode,要求使用condition類來寫,
題意:
編寫一個可以從 1 到 n 輸出代表這個數(shù)字的字符串的程序，但是：
如果這個數(shù)字可以被 3 整除，輸出 "fizz"。
如果這個數(shù)字可以被 5 整除，輸出 "buzz"。
如果這個數(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);
}
}
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
Java中final,finally,finalize三個關(guān)鍵字的區(qū)別_動力節(jié)點(diǎn)Java學(xué)院整理
這篇文章給大家收集整理了有關(guān)java中final,finally,finalize三個關(guān)鍵字的區(qū)別介紹，非常不錯，具有參考借鑒價值，需要的的朋友參考下吧2017-04-04
Spring Boot整合Swagger測試api構(gòu)建全紀(jì)錄
這篇文章主要給大家介紹了關(guān)于Spring Boot整合Swagger測試api構(gòu)建的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-01-01
SpringBoot?整合ChatGPT?API項目實(shí)戰(zhàn)教程
這篇文章主要介紹了SpringBoot整合ChatGPT API項目實(shí)戰(zhàn)教程,本文通過示例代碼給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2023-05-05
在開發(fā)過程中經(jīng)常會使用到j(luò)ava string類的方法,本文將以此問題進(jìn)行詳細(xì)介紹2012-11-11
這篇文章主要為大家詳細(xì)介紹了java實(shí)現(xiàn)文件下載的兩種方式，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-11-11
這篇文章主要介紹了Spring?Boot?Rest常用框架注解，通過將嘗試解釋Spring?Boot?Rest?API的不同注釋，這些注釋是Spring?Boot中REST?API所必需的，需要的朋友可以參考一下2022-06-06
java8 stream多字段排序的實(shí)現(xiàn)
這篇文章主要介紹了java8 stream多字段排序的實(shí)現(xiàn)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-03-03
Spring Boot 對多環(huán)境整合已經(jīng)有了很好的支持,能夠在運(yùn)行間、打包時自由切換環(huán)境,這篇文章主要介紹了SpringBoot指定激活配置文件,需要的朋友可以參考下2023-11-11
本文給大家分享java xml轉(zhuǎn)為json的兩種方法，每種方法通過實(shí)例代碼給大家介紹的非常詳細(xì)，小編感覺第一種方法要比第二種方法好些，具體實(shí)現(xiàn)代碼跟隨小編一起看看吧2021-08-08
Java將網(wǎng)絡(luò)圖片轉(zhuǎn)成輸入流以及將url轉(zhuǎn)成InputStream問題
這篇文章主要介紹了Java將網(wǎng)絡(luò)圖片轉(zhuǎn)成輸入流以及將url轉(zhuǎn)成InputStream問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01