Java並發–基礎知識

• 2020 年 8 月 7 日
• 筆記
• 基礎, 並發, 面試, 面試分享

一、為什麼要用到並發

充分利用多核CPU的計算能力

方便進行業務拆分，提升應用性能

二、並發編程有哪些缺點

頻繁的上下文切換

時間片是CPU分配給各個線程的時間，因為時間非常短，所以CPU不斷通過切換線程，讓我們覺得是不斷執行的，時間片一般是幾十毫秒。而每次切換時，需要保存當前的狀態，以便能夠進行回復當期狀態。而這個切換是非常損耗性能，過於頻繁反而無法發揮出多線程編程的優勢。通常減少上下文切換可以採用無鎖並發編程，CAS算法，使用最少的線程和使用協程。

比如：悲觀鎖就會導致頻繁的上下文切換，而頻繁的上下文切換可能無法發揮出多線程編程的優勢

無鎖並發編程

可以參照jdk1.7分段鎖的思想，不同的線程處理不同的數據，這樣在多線程競爭的條件下，可以減少上下文切換的時間

CAS算法

利用Atomic下使用CAS（compare and swap）算法來更新數據，使用了樂觀鎖，可以有效的減少一部分不必要的鎖競爭帶來的上下文切換。

使用最少的線程

避免創建不必要的線程，比如任務很少，但是創建了很多的線程，這樣會造成大量的線程都處於等待狀態。

線程安全–死鎖

多線程編程中最難以把握的就是臨界區線程安全問題，稍微不注意就會出現死鎖的情況，一旦產生死鎖就會造成系統功能不可用。

避免死鎖

• • 避免一個線程同時獲得多個鎖
  • 避免一個線程在鎖內佔有多個資源，盡量保證每個所只佔有一個資源
  • 嘗試使用定時鎖，使用lock.tryLock(TimeOut)，當超時等待時當前線程不會阻塞
  • 對於數據庫，加鎖和解鎖必須在一個數據庫連接里，否則會出現解鎖失敗的情況

三、並行和並發

並髮指的是多個任務交替執行，而並行指的是真正意義上的同時進行

實際上，如果系統內只有一個CPU，而使用多線程時，那麼真實系統環境下不能並行，只能通過切換時間片的方式交替進行，而成為並發執行任務。真正的並行也只能出現在擁有多個CPU的系統中。

四、同步和異步

同步和異步通常用來形容一次方法的調用

同步方法調用一開始，調用者必須等待被調用的方法結束後，調用者後面的代碼才能執行。而異步調用，指的是，調用者不管被調用方法是否完成，都會繼續執行後面的代碼，當被調用的方法完成後會通知調用者。

五、阻塞和非阻塞

阻塞和非阻塞常用來形容多線程間的相互影響。

比如一個線程佔有了臨界區資源，那麼其他線程需要這個資源就必須進行等待該資源的釋放，會導致等待的線程掛起，這種情況就是阻塞，而非阻塞就恰好相反，它強調沒有一個線程可以阻塞其他線程，所有的線程都會嘗試的往前運行

六、線程的臨界區資源

臨界區用來表示一種公共資源或者說共享數據，可以被多個線程使用，但是每一個線程使用時，一旦臨界區資源被一個線程佔有，那麼其它線程必須等待。

七、新建線程有哪幾種方式

一個Java線程從main()方法開始執行，然後按照既定的代碼邏輯執行，看似沒有其他線程參與，但是實際上Java程序天生就是一個多線程程序，包含了：

• 分發出路發送給JVM信號的線程
• 調用對象的finalize方法的線程
• 清除Reference的線程
• main線程，用戶程序的入口

三種方式（有三種方式實現，JDK源碼中標明只有兩種方式）

1、繼承Thread類，重寫run方法

2、實現Runnable接口

3、實現Callable接口

public class NewThread {
    /*擴展自Thread類*/
    private static class UseThread extends Thread{
        @Override
        public void run() {
            super.run();
            // do my work;
            System.out.println("I am extendec Thread");
        }
    }

    
    /*實現Runnable接口*/
    private static class UseRunnable implements Runnable{

        @Override
        public void run() {
            // do my work;
            System.out.println("I am implements Runnable");
        }
    }
    

    public static void main(String[] args) 
            throws InterruptedException, ExecutionException {
        UseThread useThread = new UseThread();
        useThread.start();
        useThread.start();

        UseRunnable useRunnable = new UseRunnable();
        new Thread(useRunnable).start();

        
    }
}

public class UseFuture {
    
    
    /*實現Callable接口，允許有返回值*/
    private static class UseCallable implements Callable<Integer>{
        private int sum;
        @Override
        public Integer call() throws Exception {
            for(int i=0 ;i<5000;i++){
                if(Thread.currentThread().isInterrupted()) {return null;
                }
                sum=sum+i;
                System.out.println("sum="+sum);
            }  return sum; 
        }
    }
    
    public static void main(String[] args) 
            throws InterruptedException, ExecutionException {

        UseCallable useCallable = new UseCallable();
        //包裝
        FutureTask<Integer> futureTask = new FutureTask<>(useCallable);
        Random r = new Random();
        new Thread(futureTask).start();

        Thread.sleep(1);
        if(r.nextInt(100)>50){
            System.out.println("Get UseCallable result = "+futureTask.get());
        }else{
            futureTask.cancel(true);
        }

    }

}

八、線程的轉換狀態

•  線程創建之後調用start()方法開始運行，當調用wait()，join()，LockSupport.lock()方法線程會進入到WAITING狀態。
• 而同樣的wait(long timeout)，sleep(long time)，join()，LockSupport.parkNamos()，LockSupport.parkUtil()增加了超時等待的功能，也就是調用這些方法後線程會進入TIME_WAITING狀態
• 當超時等待時間到達後線程會切換到RUNNABLE的狀態，另外當WAITING和TIME_WAITING狀態是可以通過notify/notifyAll方法使線程轉換到RUNNABLE狀態
• 當線程出現資源競爭時，即等待獲取鎖的時候，線程會進入到BLOCKED阻塞狀態
• 當線程獲取鎖時，線程進入到RUNNABLE狀態
• 線程運行結束，線程進入到TERMINATED狀態，狀態轉換可以說是線程的聲明周期

另外需要注意的是：

當線程進入到synchronized方法或者synchronize的代碼塊的時候，線程切換的是BLOCKED狀態，而使用lock進行加鎖的時候線程切換的是WAITING或者TIME_WAITING狀態，因為lock會調用LockSupport的方法

九、中斷標誌位–interrupted

中斷可以理解為線程的一個標誌位，它代表了一個運行中的線程是否被其他線程進行了中斷操作。

中斷好比其他線程對該線程打了一個招呼。其他線程可以調用該線程的interrupt()方法對其進行中斷操作，同時該線程可以調用isInterrupted()來感知其他線程對自身的中斷操作，從而做出響應。

另外，同樣可以調用Thread的靜態方法interrupted()對當前線程進行中斷操作，該方法會清除中斷標誌位。

需要注意的是，當拋出interruptedExection時候，會清除中斷標誌位，也就是說在調用isInterrupted時會返回false。

十、join

如果一個線程實例A執行了threadB.join()，其含義是：當前線程A會等待線程threadB線程終止後threadA才會繼續執行

關於join方法一共提供了如下這些方法

 public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }


public final void join() throws InterruptedException {
        join(0);
    }

Thread類出了提供join()方法外，另外還提供了超時等待的方法，如果線程threadB在等待的時間內還沒有結束的話，threadA會在超時之後繼續執行。join方法源碼的關鍵是

while (isAlive()) {
                wait(0);
            }

可以看出來當前等待對象threasA會一直阻塞，知道被等待對象threadB結束後即isAlive()返回false的時候才會結束while循環，當天threadB退出時會調用notifyAll方法通知所有的等待線程。

十一、sleep和wait

  public static native void sleep(long millis) throws InterruptedException;

該方法顯然是Thread的靜態方法，很顯然它是讓當前線程按照指定的時間休眠，其休眠時間的精度取決於處理器的計時器和調度器

需要注意的是如果當前線程獲得了鎖，sleep方法並不會失去鎖。sleep方法經常拿來和object.wait()方法進行比較，這也是面試經常被問到的地方

sleep()和wait()的區別

1.sleep方法是threa的靜態方法，而wait是objectshilde方法；

2、wait方法必須要在同步方法或者同步塊中調用，也就是必須獲得對象鎖，而sleep方法沒有這個限制，可以在任何地方使用

3、wait方法會釋放佔有的對象鎖，使線程進入到等待池中，等待下一次獲取資源。而sleep方法只是會讓出CPU並不會釋放掉對象鎖

4、sleep方法在休眠時間達到後如果再次獲取CPU時間片就會繼續執行，而wait方法必須等到notify/notifyAll通知後，才會離開等待池，並且再次獲取CPU時間片才會繼續執行

十二、yield

 public static native void yield();

1、這是一個thread的靜態方法

2、一旦執行，它會是當前線程讓出CPU，但是，需要注意的是，讓出的CPU並不是代表當前線程不在運行了，吐過在下一次競爭中，又獲得CPU時間片當前線程依舊會繼續運行。另外讓出的時間片智慧分配給當前相同優先級的線程

3、需注意的是sleep和yield方法，同樣都是當前線程會交出處理器資源，而它們不同的是，sleep交出來的時間片其他線程都可以去競爭，也就是說都有機會獲得當前線程讓出的時間片。而yield方法只允許與當前具有相同優先級的線程能夠獲得釋放出來的CPU時間片。

十三、線程的優先級

在 Java 線程中，通過一個整型成員變量 priority 來控制優先級，優先級的范圍從 1~10，在線程構建的時候可以通過 setPriority(int)方法來修改優先級，默認優先級是5，優先級高的線程分配時間片的數量要多於優先級低的線程。

設置線程優先級時，針對頻繁阻塞（休眠或者 I/O 操作）的線程需要設置較高優先級，而偏重計算（需要較多 CPU 時間或者偏運算）的線程則設置較低的優先級，確保處理器不會被獨佔。在不同的 JVM 以及操作系統上，線程規劃會存在差異，有些操作系統甚至會忽略對線程優先級的設定。

 十四、守護線程

Daemon（守護）線程是一種支持型線程，因為它主要被用作程序中後台調度以及支持性工作。這意味着，當一個 Java 虛擬機中不存在非 Daemon 線程的時候，Java 虛擬機將會退出。可以通過調用 Thread.setDaemon(true)將線程設置為 Daemon 線程。我們一般用不上，比如垃圾回收線程就是 Daemon 線程。