Java高併發學習筆記（二）：線程安全與ThreadGroup

時間  2021-05-11
標籤 java 編程 數組 緩存 bash 服務器 多線程 架構 併發 app 欄目 Java 简体版
原文   原文鏈接

1 來源

  • 來源：《Java高併發編程詳解 多線程與架構設計》，汪文君著
  • 章節：第4、六章

本文是兩章的筆記整理。java

2 概述

本文主要講述了synchronized以及ThreadGroup的基本用法。編程

3 synchronized

3.1 簡介

synchronized能夠防止線程干擾和內存一致性錯誤，具體表現以下：數組

  • synchronized提供了一種鎖機制，可以確保共享變量的互斥訪問，從而防止數據不一致的問題
  • synchronized包括monitor enter和monitor exit兩個JVM指令，能保證在任什麼時候候任何線程執行到monitor enter成功以前都必須從主存獲取數據，而不是從緩存中，在monitor exit運行成功以後，共享變量被更新後的值必須刷入主內存而不是僅僅在緩存中
  • synchronized指令嚴格遵循Happens-Beofre規則，一個monitor exit指令以前一定要有一個monitor enter

3.2 基本用法

synchronized的基本用法能夠用於對代碼塊或方法進行修飾，好比：緩存

private final Object MUTEX = new Object();
    
public void sync1(){
    synchronized (MUTEX){
    }
}

public synchronized void sync2(){
}

3.3 字節碼簡單分析

一個簡單的例子以下：bash

public class Main {
    private static final Object MUTEX = new Object();

    public static void main(String[] args) throws InterruptedException {
        final Main m = new Main();
        for (int i = 0; i < 5; i++) {
            new Thread(m::access).start();
        }
    }

    public void access(){
        synchronized (MUTEX){
            try{
                TimeUnit.SECONDS.sleep(20);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

編譯後查看字節碼：服務器

javap -v -c -s -l Main.class

access()字節碼截取以下：多線程

stack=3, locals=4, args_size=1
 0: getstatic     #9                  // Field MUTEX:Ljava/lang/Object;  獲取MUTEX
 3: dup
 4: astore_1
 5: monitorenter                      // 執行monitor enter指令
 6: getstatic     #10                 // Field java/util/concurrent/TimeUnit.SECONDS:Ljava/util/concurrent/TimeUnit;
 9: ldc2_w        #11                 // long 20l
12: invokevirtual #13                 // Method java/util/concurrent/TimeUnit.sleep:(J)V
15: goto          23                  // 正常退出，跳轉到字節碼偏移量23的地方
18: astore_2
19: aload_2
20: invokevirtual #15                 // Method java/lang/InterruptedException.printStackTrace:()V
23: aload_1
24: monitorexit                          // monitor exit指令
25: goto          33
28: astore_3
29: aload_1
30: monitorexit
31: aload_3
32: athrow
33: return

關於monitorenter與monitorexit說明以下：架構

  • monitorenter：每個對象與一個monitor相對應，一個線程嘗試獲取與對象關聯的monitor的時候，若是monitor的計數器爲0，會得到以後當即對計數器加1，若是一個已經擁有monitor全部權的線程重入，將致使計數器再次累加，而若是其餘線程嘗試獲取時，會一直阻塞直到monitor的計數器變爲0，才能再次嘗試獲取對monitor的全部權
  • monitorexit：釋放對monitor的全部權，將monitor的計數器減1，若是計數器爲0，意味着該線程再也不擁有對monitor的全部權

3.4 注意事項

3.4.1 非空對象

與monitor關聯的對象不能爲空：併發

private Object MUTEX = null;
private void sync(){
    synchronized (MUTEX){

    }
}

會直接拋出空指針異常。app

3.4.2 做用域不當

因爲synchronized關鍵字存在排它性，做用域越大，每每意味着效率越低，甚至喪失併發優點，好比：

private synchronized void sync(){
    method1();
    syncMethod();
    method2();
}

其中只有第二個方法是併發操做，那麼能夠修改成

private Object MUTEX = new Object();
private void sync(){
    method1();
    synchronized (MUTEX){
        syncMethod();
    }
    method2();
}

3.4.3 使用不一樣的對象

由於一個對象與一個monitor相關聯，若是使用不一樣的對象，這樣就失去了同步的意義，例子以下：

public class Main {
    public static class Task implements Runnable{
        private final Object MUTEX = new Object();

        @Override
        public void run(){
            synchronized (MUTEX){
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            new Thread(new Task()).start();
        }
    }
}

每個線程爭奪的monitor都是互相獨立的，這樣就失去了同步的意義，起不到互斥的做用。

3.5 死鎖

另外，使用synchronized還須要注意的是有可能形成死鎖的問題，先來看一下形成死鎖可能的緣由。

3.5.1 死鎖成因

  • 交叉鎖致使程序死鎖：好比線程A持有R1的鎖等待R2的鎖，線程B持有R2的鎖等待R1的鎖
  • 內存不足：好比兩個線程T1和T2，T1已獲取10MB內存，T2獲取了15MB內存，T1和T2都須要獲取30MB內存才能工做，可是剩餘可用的內存爲10MB，這樣兩個線程都在等待彼此釋放內存資源
  • 一問一答式的數據交換：服務器開啓某個端口，等待客戶端訪問，客戶端發送請求後，服務器因某些緣由錯過了客戶端請求，致使客戶端等待服務器迴應，而服務器等待客戶端發送請求
  • 死循環引發的死鎖：比較常見，使用jstack等工具看不到死鎖，可是程序不工做，CPU佔有率高，這種死鎖也叫系統假死，難以排查和重現

3.5.2 例子

public class Main {
    private final Object MUTEX_READ = new Object();
    private final Object MUTEX_WRITE = new Object();

    public void read(){
        synchronized (MUTEX_READ){
            synchronized (MUTEX_WRITE){
            }
        }
    }

    public void write(){
        synchronized (MUTEX_WRITE){
            synchronized (MUTEX_READ){
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Main m = new Main();
        new Thread(()->{
            while (true){
                m.read();
            }
        }).start();
        new Thread(()->{
            while (true){
                m.write();
            }
        }).start();
    }
}

兩個線程分別佔有MUTEX_READ/MUTEX_WRITE，同時等待另外一個線程釋放MUTEX_WRITE/MUTEX_READ，這就是交叉鎖形成的死鎖。

3.5.3 排查

使用jps找到進程後，經過jstack查看：

在這裏插入圖片描述

能夠看到明確的提示找到了1個死鎖，Thread-0等待被Thread-1佔有的monitor，而Thread-1等待被Thread-0佔有的monitor。

3.6 兩個特殊的monitor

這裏介紹兩個特殊的monitor：

  • this monitor
  • class monitor

3.6.1 this monitor

先上一段代碼：

public class Main {
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName()+" method1");
        try{
            TimeUnit.MINUTES.sleep(5);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName()+" method2");
        try{
            TimeUnit.MINUTES.sleep(5);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Main m = new Main();
        new Thread(m::method1).start();
        new Thread(m::method2).start();
    }
}

運行以後能夠發現，只有一行輸出，也就是說，只是運行了其中一個方法，另外一個方法根本沒有執行，使用jstack能夠發現：

在這裏插入圖片描述

一個線程處於休眠中，而另外一個線程處於阻塞中。而若是將method2()修改以下：

public void method2(){
    synchronized (this) {
        System.out.println(Thread.currentThread().getName() + " method2");
        try {
            TimeUnit.MINUTES.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

效果是同樣的。也就是說，在方法上使用synchronized，等價於synchronized(this)。

3.6.2 class monitor

把上面的代碼中的方法修改成靜態方法：

public class Main {
    public static synchronized void method1() {
        System.out.println(Thread.currentThread().getName() + " method1");
        try {
            TimeUnit.MINUTES.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + " method2");
        try {
            TimeUnit.MINUTES.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(Main::method1).start();
        new Thread(Main::method2).start();
    }
}

運行以後能夠發現輸出仍是隻有一行，也就是說只運行了其中一個方法，jstack分析也相似：

在這裏插入圖片描述

而若是將method2()修改以下：

public static void method2() {
    synchronized (Main.class) {
        System.out.println(Thread.currentThread().getName() + " method2");
        try {
            TimeUnit.MINUTES.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

能夠發現輸出仍是一致，也就是說，在靜態方法上的synchronized，等價於synchronized(XXX.class)。

3.6.3 總結

  • this monitor：在成員方法上的synchronized，就是this monitor，等價於在方法中使用synchronized(this)
  • class monitor：在靜態方法上的synchronized，就是class monitor，等價於在靜態方法中使用synchronized(XXX.class)

4 ThreadGroup

4.1 簡介

不管什麼狀況下，一個新建立的線程都會加入某個ThreadGroup中：

  • 若是新建線程沒有指定ThreadGroup，默認就是main線程所在的ThreadGroup
  • 若是指定了ThreadGroup，那麼就加入該ThreadGroup中

ThreadGroup中存在父子關係，一個ThreadGroup能夠存在子ThreadGroup。

4.2 建立

建立ThreadGroup能夠直接經過構造方法建立，構造方法有兩個，一個是直接指定名字（ThreadGroup爲main線程的ThreadGroup），一個是帶有父ThreadGroup與名字的構造方法：

ThreadGroup group1 = new ThreadGroup("name");
ThreadGroup group2 = new ThreadGroup(group1,"name2");

完整例子：

public static void main(String[] args) throws InterruptedException {
    ThreadGroup group1 = new ThreadGroup("name");
    ThreadGroup group2 = new ThreadGroup(group1,"name2");
    System.out.println(group2.getParent() == group1);
    System.out.println(group1.getParent().getName());
}

輸出結果：

true
main

4.3 enumerate()

enumerate()可用於Thread和ThreadGroup的複製，由於一個ThreadGroup能夠加入若干個Thread以及若干個子ThreadGroup，使用該方法能夠方便地進行復制。方法描述以下：

  • public int enumerate(Thread [] list)
  • public int enumerate(Thread [] list, boolean recurse)
  • public int enumerate(ThreadGroup [] list)
  • public int enumerate(ThreadGroup [] list, boolean recurse)

上述方法會將ThreadGroup中的活躍線程/ThreadGroup複製到Thread/ThreadGroup數組中，布爾參數表示是否開啓遞歸複製。

例子以下：

public static void main(String[] args) throws InterruptedException {
    ThreadGroup myGroup = new ThreadGroup("MyGroup");
    Thread thread = new Thread(myGroup,()->{
        while (true){
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    },"MyThread");
    thread.start();
    TimeUnit.MILLISECONDS.sleep(1);
    ThreadGroup mainGroup = currentThread().getThreadGroup();
    Thread[] list = new Thread[mainGroup.activeCount()];
    int recurseSize = mainGroup.enumerate(list);
    System.out.println(recurseSize);
    recurseSize = mainGroup.enumerate(list,false);
    System.out.println(recurseSize);
}

後一個輸出比前一個少1，由於不包含myGroup中的線程（遞歸設置爲false）。須要注意的是，enumerate()獲取的線程僅僅是一個預估值，並不能百分百地保證當前group的活躍線程，好比調用複製以後，某個線程結束了生命週期或者新的線程加入進來，都會致使數據不許確。另外，返回的int值相較起Thread[]的長度更爲真實，由於enumerate僅僅將當前活躍的線程分別放進數組中，而返回值int表明的是真實的數量而不是數組的長度。

4.4 其餘API

  • activeCount()：獲取group中活躍的線程，估計值
  • activeGroupCount()：獲取group中活躍的子group，也是一個近似值，會遞歸獲取全部的子group
  • getMaxPriority()：用於獲取group的優先級，默認狀況下，group的優先級爲10，且全部線程的優先級不得大於線程所在group的優先級
  • getName()：獲取group名字
  • getParent()：獲取父group，若是不存在返回null
  • list()：一個輸出方法，遞歸輸出全部活躍線程信息到控制檯
  • parentOf(ThreadGroup g)：判斷當前group是否是給定group的父group，若是給定的group是本身自己，也會返回true
  • setMaxPriority(int pri)：指定group的最大優先級，設定後也會改變全部子group的最大優先級，另外，修改優先級後會出現線程優先級大於group優先級的狀況，好比線程優先級爲10，設置group優先級爲5後，線程優先級就大於group優先級，可是新加入的線程優先級必須不能大於group優先級
  • interrupt()：致使全部的活躍線程被中斷，遞歸調用線程的interrupt()
  • destroy()：若是沒有任何活躍線程，調用後在父group中將本身移除
  • setDaemon(boolean daemon)：設置爲守護ThreadGroup後，若是該ThreadGroup沒有任何活躍線程，自動被銷燬
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程