Java自學-多線程 Lock對象

来源:https://www.cnblogs.com/jeddzd/archive/2020/03/06/12431055.html
-Advertisement-
Play Games

多線程 Lock對象 與synchronized類似的，lock也能夠達到同步的效果 步驟 1 : 回憶 synchronized 同步的方式 首先回憶一下 synchronized 同步對象的方式 當一個線程占用 synchronized 同步對象，其他線程就不能占用了，直到釋放這個同步對象為止 ...


多線程 Lock對象

與synchronized類似的，lock也能夠達到同步的效果

步驟 1 : 回憶 synchronized 同步的方式

首先回憶一下 synchronized 同步對象的方式

當一個線程占用 synchronized 同步對象，其他線程就不能占用了，直到釋放這個同步對象為止

回憶 synchronized 同步的方式

package multiplethread;
   
import java.text.SimpleDateFormat;
import java.util.Date;
    
public class TestThread {
      
    public static String now(){
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
      
    public static void main(String[] args) {
        final Object someObject = new Object();
           
        Thread t1 = new Thread(){
            public void run(){
                try {
                    System.out.println( now()+" t1 線程已經運行");
                    System.out.println( now()+this.getName()+ " 試圖占有對象：someObject");
                    synchronized (someObject) {
                           
                        System.out.println( now()+this.getName()+ " 占有對象：someObject");
                        Thread.sleep(5000);
                        System.out.println( now()+this.getName()+ " 釋放對象：someObject");
                    }
                    System.out.println(now()+" t1 線程結束");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t1.setName(" t1");
        t1.start();
        Thread t2 = new Thread(){
   
            public void run(){
                try {
                    System.out.println( now()+" t2 線程已經運行");
                    System.out.println( now()+this.getName()+ " 試圖占有對象：someObject");
                    synchronized (someObject) {
                        System.out.println( now()+this.getName()+ " 占有對象：someObject");
                        Thread.sleep(5000);
                        System.out.println( now()+this.getName()+ " 釋放對象：someObject");
                    }
                    System.out.println(now()+" t2 線程結束");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t2.setName(" t2");
        t2.start();
    }
        
}

步驟 2 : 使用Lock對象實現同步效果

Lock是一個介面，為了使用一個Lock對象，需要用到

Lock lock = new ReentrantLock();

與 synchronized (someObject) 類似的，lock()方法，表示當前線程占用lock對象，一旦占用，其他線程就不能占用了。
與 synchronized 不同的是，一旦synchronized 塊結束，就會自動釋放對someObject的占用。 lock卻必須調用unlock方法進行手動釋放，為了保證釋放的執行，往往會把unlock() 放在finally中進行。

使用Lock對象實現同步效果

package multiplethread;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class TestThread {
 
    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
 
    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }
 
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
 
        Thread t1 = new Thread() {
            public void run() {
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
 
                    lock.lock();
 
                    log("占有對象：lock");
                    log("進行5秒的業務操作");
                    Thread.sleep(5000);
 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("釋放對象：lock");
                    lock.unlock();
                }
                log("線程結束");
            }
        };
        t1.setName("t1");
        t1.start();
        try {
            //先讓t1飛2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {
 
            public void run() {
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
 
                    lock.lock();
 
                    log("占有對象：lock");
                    log("進行5秒的業務操作");
                    Thread.sleep(5000);
 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("釋放對象：lock");
                    lock.unlock();
                }
                log("線程結束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
 
}

步驟 3 : trylock方法

synchronized 是不占用到手不罷休的，會一直試圖占用下去。
與 synchronized 的鑽牛角尖不一樣，Lock介面還提供了一個trylock方法。
trylock會在指定時間範圍內試圖占用，占成功了，就啪啪啪。 如果時間到了，還占用不成功，扭頭就走~

註意： 因為使用trylock有可能成功，有可能失敗，所以後面unlock釋放鎖的時候，需要判斷是否占用成功了，如果沒占用成功也unlock,就會拋出異常

trylock方法

package multiplethread;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class TestThread {
 
    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
 
    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }
 
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
 
        Thread t1 = new Thread() {
            public void run() {
                boolean locked = false;
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
 
                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    if(locked){
                        log("占有對象：lock");
                        log("進行5秒的業務操作");
                        Thread.sleep(5000);
                    }
                    else{
                        log("經過1秒鐘的努力，還沒有占有對象，放棄占有");
                    }
 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                     
                    if(locked){
                        log("釋放對象：lock");
                        lock.unlock();
                    }
                }
                log("線程結束");
            }
        };
        t1.setName("t1");
        t1.start();
        try {
            //先讓t1飛2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {
 
            public void run() {
                boolean locked = false;
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
 
                    locked = lock.tryLock(1,TimeUnit.SECONDS);
                    if(locked){
                        log("占有對象：lock");
                        log("進行5秒的業務操作");
                        Thread.sleep(5000);
                    }
                    else{
                        log("經過1秒鐘的努力，還沒有占有對象，放棄占有");
                    }
 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                     
                    if(locked){
                        log("釋放對象：lock");
                        lock.unlock();
                    }
                }
                log("線程結束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
 
}

步驟 4 : 線程交互

使用synchronized方式進行線程交互，用到的是同步對象的wait,notify和notifyAll方法

Lock也提供了類似的解決辦法，首先通過lock對象得到一個Condition對象，然後分別調用這個Condition對象的：await, signal,signalAll 方法

註意： 不是Condition對象的wait,nofity,notifyAll方法,是await,signal,signalAll

線程交互

package multiplethread;
  
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
  
public class TestThread {
  
    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
  
    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }
  
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
         
        Thread t1 = new Thread() {
            public void run() {
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
  
                    lock.lock();
  
                    log("占有對象：lock");
                    log("進行5秒的業務操作");
                    Thread.sleep(5000);
                    log("臨時釋放對象 lock， 並等待");
                    condition.await();
                    log("重新占有對象 lock，併進行5秒的業務操作");
                    Thread.sleep(5000);
  
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("釋放對象：lock");
                    lock.unlock();
                }
                log("線程結束");
            }
        };
        t1.setName("t1");
        t1.start();
        try {
            //先讓t1飛2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {
  
            public void run() {
                try {
                    log("線程啟動");
                    log("試圖占有對象：lock");
  
                    lock.lock();
  
                    log("占有對象：lock");
                    log("進行5秒的業務操作");
                    Thread.sleep(5000);
                    log("喚醒等待中的線程");
                    condition.signal();
  
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("釋放對象：lock");
                    lock.unlock();
                }
                log("線程結束");
            }
        };
        t2.setName("t2");
        t2.start();
    }
  
}

步驟 5 : 總結Lock和synchronized的區別

  1. Lock是一個介面，而synchronized是Java中的關鍵字，synchronized是內置的語言實現，Lock是代碼層面的實現。

  2. Lock可以選擇性的獲取鎖，如果一段時間獲取不到，可以放棄。synchronized不行，會一根筋一直獲取下去。 藉助Lock的這個特性，就能夠規避死鎖，synchronized必須通過謹慎和良好的設計，才能減少死鎖的發生。

  3. synchronized在發生異常和同步塊結束的時候，會自動釋放鎖。而Lock必須手動釋放， 所以如果忘記了釋放鎖，一樣會造成死鎖。

練習： 多線程 Lock對象

當多個線程按照不同順序占用多個同步對象的時候，就有可能產生死鎖現象。

死鎖之所以會發生，就是因為synchronized 如果占用不到同步對象，就會苦苦的一直等待下去，藉助tryLock的有限等待時間，解決死鎖問題

答案 :
在這裡插入圖片描述

package multiplethread;
  
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
  
public class TestThread {
  
    public static void main(String[] args) throws InterruptedException {
        Lock lock_ahri = new ReentrantLock();
        Lock lock_annie = new ReentrantLock();
  
        Thread t1 = new Thread() {
            public void run() {
                // 占有九尾妖狐
                boolean ahriLocked = false;
                boolean annieLocked = false;
                  
                try {
                    ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
                    if (ahriLocked) {
                        System.out.println("t1 已占有九尾妖狐");
                        // 停頓1000秒，另一個線程有足夠的時間占有安妮
                        Thread.sleep(1000);
                        System.out.println("t1 試圖在10秒內占有安妮");
                        try {
                            annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
                            if (annieLocked)
                                System.out.println("t1 成功占有安妮，開始啪啪啪");
                            else{
                                System.out.println("t1 老是占用不了安妮，放棄");
                            }
  
                        } finally {
                            if (annieLocked){
                                System.out.println("t1 釋放安妮");
                                lock_annie.unlock();
                            }
                        }
  
                    }
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } finally {
                    if (ahriLocked){
                        System.out.println("t1 釋放九尾狐");
                        lock_ahri.unlock();
                    }
                }
  
            }
        };
        t1.start();
          
        Thread.sleep(100);
          
        Thread t2 = new Thread() {
            public void run() {
                boolean annieLocked = false;
                boolean ahriLocked = false;
                                  
                try {annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
                  
                if (annieLocked){
                      
                        System.out.println("t2 已占有安妮");
                        // 停頓1000秒，另一個線程有足夠的時間占有安妮
                        Thread.sleep(1000);
                        System.out.println("t2 試圖在10秒內占有九尾妖狐");
                        try {
                            ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
                            if (ahriLocked)
                                System.out.println("t2 成功占有九尾妖狐，開始啪啪啪");
                            else{
                                System.out.println("t2 老是占用不了九尾妖狐，放棄");
                            }
                        }
                        finally {
                            if (ahriLocked){
                                System.out.println("t2 釋放九尾狐");
                                lock_ahri.unlock();
                            }
                                  
                        }
  
                    }
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } finally {
                    if (annieLocked){
                        System.out.println("t2 釋放安妮");
                        lock_annie.unlock();
                    }
                          
                }
            }
        };
        t2.start();
      
    }
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 1.numpy介紹
    NumPy(Numerical Python) 是 Python 語言的一個擴展程式庫，支持大量的維度數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。NumPy 是一個運行速度非常快的數學庫，主要用於數組計算，包含：一個強大的N維數組對象 ndarray；廣播功能函數；整合 C/C++/Fo ...
  • Python爬蟲下載視頻文件部分源碼
    分享一下我自己整理的代碼，改兩個參數就可使用（掃描下方二維碼獲取python學習資料） import requests import time headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebK ...
  • openOPC與監控頁面二
    本文通過結合上一篇博文《openOPC與監控頁面一》展現瞭如何通過通過一步一步實現UI端到OPC服務端數據刷新的技術驗證過程， ...
  • 多線程筆記：同步機制（1）
    同步機制簡介 線程同步機制是一套用於協調線程間的數據訪問及活動的機制，該機制用於保障線程安全以及實現這些線程的共同目標。 線程同步機制是編程語言為多線程運行制定的一套規則，合理地運用這些規則可以很大程度上保障程式的正確運行。 這套機制包含兩方面的內容，一是關於多線程間的數據訪問的規則，二是多線程間活 ...
  • Redis管道之Java與Go代碼示例
    最近讀了Redis官網一篇關於使用管道加速Redis查詢 的文章，原文： "Using pipelining to speedup Redis queries" ，中文翻譯可參考： "管道（Pipelining）" 一個請求/響應伺服器能處理新的請求即使客戶端還未讀取舊的響應。這樣就可以將多個命令發 ...
  • 【java框架】Spring(1) -- Spring入門
    Spring入門 1. Spring認識 Spring是一個輕量級的DI（IOC）和AOP的容器框架。 IOC（Inverse of control）：控制反轉，把業務層管理數據層生命周期的控制權交給Spring容器去管理，自己不再去管理數據層的生命周期（創建對象，銷毀對象）。 DI（Depende ...
  • 《自拍教程37》段位進階註意事項
    三種編程思維（實現方式） 由於本思維篇，主要介紹通過簡單而實用的測試案例，逐步培養編程思維： 先學會批處理腳本實現，在學會面向過程函數來實現，最後學會面向對象類的實現。 每一個案例故事對應三種實現方式 每篇文章，都有一個案例故事，代表實際測試場景故事， 有些測試案例，其實有些“批處理腳本”實現最為合 ...
  • spring——AOP原理及源碼（三）
    在上一篇中，我們創建併在BeanFactory中註冊了AnnotationAwareAspectJAutoProxyCreator組件。本篇我們將要探究，這個組件是在哪裡以及何時發揮作用的。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類