溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
小編給大家分享一下Java介紹Lock鎖與生產者消費者問題，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！
Lock鎖與生產者消費者問題
傳統Synchronized鎖
Lock鎖
Synchronized和lock鎖的區別
傳統的生產者和消費者問題
Lock版的生產者和消費者問題
Condition實現精準通知喚醒
傳統Synchronized鎖
實現一個基本的售票例子：
/*
真正的多線程開發，公司中的開發,降低耦合性
線程就是一個單獨的資源類，沒有任何附屬的操作
1.屬性，方法
* */public class SaleTicketDemo1 {
public static void main(String[] args) {
//并發，多個線程操作同一個資源類,把資源類丟入線程
Ticket ticket=new Ticket();
//Runnable借口是一個FunationalInterface函數式接口，接口可以new,jdk1.8以后，lamda表達式()->{代碼}
new Thread(()->{
for(int i=0;i<60;i++){
ticket.sale();
}
},"A").start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<60;i++){
ticket.sale();
}
}
},"B").start();
new Thread(()->{
for(int i=0;i<60;i++){
ticket.sale();
}
},"C").start();
}}//資源類 OOPclass Ticket{
//屬性，方法
private int number=50;
//賣票的方式
//synchronized本質：隊列，所
public synchronized void sale(){
if(number>0){
System.out.println(Thread.currentThread().getName()+"賣出了"+(number--)+"票,剩余"+number);
}
}}注意，這里面用到了lambda表達式，lambda表達式詳細描述見Java基礎-Lambda表達式
這是使用傳統的synchronized實現并發，synchronized的本質就是隊列，鎖。就好比食堂排隊。如果沒有排隊，就會很亂。只有給一個人服務完成了，另一個人才能接收到服務。
Lock鎖
之前已經說道，JVM提供了synchronized關鍵字來實現對變量的同步訪問以及用wait和notify來實現線程間通信。在jdk1.5以后，JAVA提供了Lock類來實現和synchronized一樣的功能，并且還提供了Condition來顯示線程間通信。
Lock類是Java類來提供的功能，豐富的api使得Lock類的同步功能比synchronized的同步更強大。
在java.util. Concurrent包中，里面有3個接口，Condition，lock(標準鎖)。ReadWriteLock鎖（讀寫鎖）
Lock實現提供比使用synchronized方法和語句可以獲得的更廣泛的鎖定操作。 它們允許更靈活的結構化，可能具有完全不同的屬性，并且可以支持多個相關聯的對象Condition。
Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }lock()表示加鎖，unlock()表示解鎖
JDK官方文檔中解釋
所有已知實現類：
ReentrantLock可重入鎖
ReentrantReadWriteLock.ReadLock 讀鎖
ReentrantReadWriteLock.writeLock寫鎖
先說ReentrantLock實現類：
ReentrantLock底層源碼構造函數
公平鎖：十分公平，可以先來后到。但是問題如果一個3s和一個3h的進程到達，3h先，那么3s等3h，實際上也不利。
非公平鎖：十分不公平，可以插隊（默認）
之后，我們會具體解釋。
怎么用，用之前加鎖，用之后解鎖
//lock鎖三部曲
//1.new ReentranLock();構造
//2.Lock.lock();加鎖
//3.finally();解鎖
public class SaleTicketDemo2 {
public static void main(String[] args) {
//并發，多個線程操作同一個資源類,把資源類丟入線程
Ticket ticket=new Ticket();
//Runnable借口是一個FunationalInterface函數式接口，接口可以new,jdk1.8以后，lamda表達式()->{代碼}
new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"A").start();
new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"B").start();
new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"C").start();
}}//資源類 OOP//lock鎖三部曲//1.new ReentranLock();//2.Lock.lock();加鎖//3.finally();解鎖class Ticket2{
//屬性，方法
private int number=50;
//賣票的方式
//synchronized本質：隊列，所
Lock lock=new ReentrantLock();
public void sale(){
lock.lock();
try {
//業務代碼
if(number>0){
System.out.println(Thread.currentThread().getName()+"賣出了"+(number--)+"票,剩余"+number);
}
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
}}Synchronized和lock鎖的區別
1.synchronized是內置的java關鍵字，lock是一個Java類
2.synchronized無法判斷獲取鎖的狀態，lock可以判斷是否獲取到了鎖
3.synchronized會自動釋放鎖(a–),lock必須要手動釋放鎖！如果不釋放鎖，會導致死鎖
4.Synchronized線程1（獲得鎖，阻塞），線程2（等待，傻傻的等）
lock.tryLock()嘗試獲取鎖，不一定會一直等待下去
5.Synchronized可重入鎖，不可以中斷的，非公平鎖。Lock,可重入鎖，可以判斷鎖，公平與非公平可以自己設置（可以自己設置）
6.synchronized適合少量的代碼同步問題，lock鎖適合鎖大量的同步代碼
synchornized鎖對象和同步代碼塊方法
傳統的生產者和消費者問題
傳統的生產者和消費者是基于Object類的wait、notify方法和synchronized關鍵字來實現的。
在面試的時候，手寫生產者消費者代碼是很常見的事情。
面試筆試經典問題：
單例模式+排序算法+生產者消費者+死鎖
生產者消費者問題synchronized版
線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒
線程交替執行 A B 操作同一個變量number=0
A num+1
B num-1
注意：加鎖的方法中，執行的思路是判斷等待+業務+通知
package testConcurrent;/*
線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒
線程交替執行 A B 操作同一個變量number=0
A num+1
B num-1
* */public class A {
public static void main(String[] args) {
Data data =new Data();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.increment();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.decrement();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"B").start();
}}//判斷等待+業務+通知class Data{ //數字。資源類
private int number=0;
//+1。多線程的情況下一定要加鎖。
public synchronized void increment() throws InterruptedException{
//判斷是否需要等待，如果不需要，就需要干活進行業務操作
if(number!=0){ //等于1的時候，需要等待，緩沖區只有1個空位置
//等待操作
this.wait();
}
number++; //進行業務操作
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他線程，我+1完畢了
this.notify();
}
//-1
public synchronized void decrement() throws InterruptedException{
if(number==0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他線程，我-1完畢了
this.notify();
}}
如圖，基本可以實現所要求的功能，但是這樣還會出現問題，如果此時我再加上了兩個線程，則
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.increment();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.decrement();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"D").start();
這里結果中出現了2，輸出結果出現了問題。為什么呢？
為什么if判斷會出現問題：
if判斷只判斷一次。因為if判斷了之后，就已經進入了代碼的等待那一行，這時，在wait下的線程可能有多個，甚至包括生產者和消費者。有可能某個生產者執行完了之后，喚醒的是另一個生產者。
在我們的官方文檔中就給出了解釋
public final void wait(long timeout) throws InterruptedException
導致當前線程等待，直到另一個線程調用此對象的notify()方法或notifyAll()方法，或指定的時間已過。
線程也可以喚醒，而不會被通知，中斷或超時，即所謂的虛假喚醒 。 雖然這在實踐中很少會發生，但應用程序必須通過測試應該使線程被喚醒的條件來防范，并且如果條件不滿足則繼續等待。 換句話說，等待應該總是出現在循環中，就像這樣：
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}注意點：防止虛假喚醒問題。
我們代碼中用的是if判斷，而應該用while判斷
package testConcurrent;/*
線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒
線程交替執行 A B 操作同一個變量number=0
A num+1
B num-1
* */public class A {
public static void main(String[] args) {
Data data =new Data();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.increment();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.decrement();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.increment();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for(int i=0;i<10;i++){
try {
data.decrement();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"D").start();
}}//判斷等待+業務+通知class Data{ //數字。資源類
private int number=0;
//+1
public synchronized void increment() throws InterruptedException{
//判斷是否需要等待，如果不需要，就需要干活進行業務操作
while(number!=0){ //等于1的時候，需要等待，緩沖區只有1個空位置
//等待操作
this.wait();
}
number++; //進行業務操作
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他線程，我+1完畢了
this.notify();
}
//-1
public synchronized void decrement() throws InterruptedException{
while(number==0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
//通知其他線程，我-1完畢了
this.notify();
}}Lock版的生產者和消費者問題
在synchronized版本中，我們使用了wait和notify來實現線程之間的同步
在lock中，
此時synchronized被lock替換了，那么wait和notify用什么來替換呢？
我們在官方文檔java.util.concurrent.locks 中，找到Lock類，然后在底部找到了
Condition newCondition()
返回一個新Condition綁定到該實例Lock實例。
在等待條件之前，鎖必須由當前線程保持。 呼叫Condition.await()將在等待之前將原子釋放鎖，并在等待返回之前重新獲取鎖。
然后我們再來了解Condition類
Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，為每個對象提供多個等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監視器方法的使用。
一個Condition實例本質上綁定到一個鎖。 要獲得特定Condition實例的Condition實例，請使用其newCondition()方法。
我們可以看到，使用的時候new一個Condition對象。然后用await替代wait,signal替換notify
代碼實現
//判斷等待+業務+通知
class Data2{ //數字。資源類
private int number=0;
Lock lock=new ReentrantLock();
Condition condition=lock.newCondition();
//+1
public void increment() throws InterruptedException{
try {
lock.lock();
//業務代碼
while(number!=0){
//等待
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"=>"+number);
condition.signalAll(); //通知
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException{
try {
lock.lock();
//業務代碼
while(number!=1){
//等待
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"=>"+number);
condition.signalAll(); //通知
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
} }注意：主函數部分于最上面的代碼一樣。
這時候雖然說是正確的，但是它是一個隨機分布的狀態，現在我們希望它有序執行，即A執行完了執行B，B執行C，C完了執行D。即精準通知。
Condition實現精準通知喚醒
Condition實現精準的通知和喚醒
我們構造三個線程，要求A執行完了執行B，B執行完了執行C，C執行完了執行D.
代碼思想：
//加多個監視器，通過監視器來判斷喚醒的是哪一個人
//設置多個同步監視器，每個監視器監視一個線程
//實例：生產線，下單->支付->交易->物流
package testConcurrent;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/*
A執行完調用B,B執行完調用C，C執行完調用A
* */public class C {
public static void main(String[] args) {
Data3 data=new Data3();
new Thread(()->{
for(int i=0;i<10;i++){
data.printA();
}
},"A").start();
new Thread(()->{
for(int i=0;i<10;i++){
data.printB();
}
},"B").start();
new Thread(()->{
for(int i=0;i<10;i++){
data.printC();
}
},"C").start();
}}class Data3{ //資源類
private Lock lock=new ReentrantLock();
//加多個監視器，通過監視器來判斷喚醒的是哪一個人
//設置多個同步監視器，每個監視器監視一個線程
//實例：生產線，下單->支付->交易->物流
private Condition condition1=lock.newCondition();
private Condition condition2=lock.newCondition();
private Condition condition3=lock.newCondition();
private int number=1; //1A 2B 3C
public void printA(){
lock.lock();
try {
//業務，判斷->執行->通知
while(number!=1){
//等待
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
//喚醒，喚醒指定的人，B
number=2; //精準喚醒
condition2.signal();
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
//業務，判斷->執行->通知
while(number!=2){
//等待
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"=>BBBBBBB");
//喚醒，喚醒指定的人，C
number=3; //精準喚醒
condition3.signal();
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
//業務，判斷->執行->通知
while(number!=3){
//等待
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"=>CCCCCCC");
//喚醒，喚醒指定的人，A
number=1; //精準喚醒
condition1.signal();
} catch (Exception e) {
// TODO: handle exception
}finally{
lock.unlock();
}
}}以上是“Java介紹Lock鎖與生產者消費者問題”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
