Java并發--基礎知識-有解無憂

一、為什么要用到并發

充分利用多核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 執行緒，

Daemon 執行緒被用作完成支持性作業，但是在 Java 虛擬機退出時 Daemon 線程中的 finally 塊并不一定會執行，在構建 Daemon 執行緒時，不能依靠 finally 塊中的內容來確保執行關倍訓清理資源的邏輯，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/96317.html

標籤：Java

上一篇：建構式語意學——Default Constructor篇

下一篇：前后端分離如何做權限控制設計？