Java并發編程的基礎知識有哪些

今天小編給大家分享一下Java并發編程的基礎知識有哪些的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

 01、簡介

首先還是的了解一下線程的基礎，這邊文章將帶著大家來了解一下線程的基礎知識。

02、線程的創建方式

1. 實現 Runnable 接口

2. 繼承 Thread 類

3. 實現 Callable 接口通過 FutureTask 包裝器來創建線程

4. 通過線程池創建線程

下面將用線程池和 Callable 的方式來創建線程

public class CallableDemo implements Callable<String> {      @Override     public String call() throws Exception {         int a=1;         int b=2;         System. out .println(a+b);         return "執行結果:"+(a+b);     }      public static void main(String[] args) throws ExecutionException, InterruptedException {         //創建一個可重用固定線程數為1的線程池         ExecutorService executorService = Executors.newFixedThreadPool (1);         CallableDemo callableDemo=new CallableDemo();         //執行線程,用future來接收線程的返回值         Future<String> future = executorService.submit(callableDemo);         //打印線程的返回值         System. out .println(future.get());         executorService.shutdown();     } }

執行結果

3 執行結果:3

03、線程的生命周期

1. NEW：初始狀態，線程被構建，但是還沒有調用 start 方法。

2. RUNNABLED：運行狀態，JAVA 線程把操作系統中的就緒和運行兩種狀態統一稱為“運行中”。調用線程的 start()  方法使線程進入就緒狀態。

3. BLOCKED：阻塞狀態，表示線程進入等待狀態,也就是線程因為某種原因放棄了 CPU 使用權。比如訪問 synchronized  關鍵字修飾的方法，沒有獲得對象鎖。

4. Waiting ：等待狀態，比如調用 wait() 方法。

5. TIME_WAITING：超時等待狀態，超時以后自動返回。比如調用 sleep(long millis) 方法

6. TERMINATED：終止狀態，表示當前線程執行完畢。

看下源碼：

public enum State {         NEW,         RUNNABLE,         BLOCKED,         WAITING,         TIMED_WAITING,         TERMINATED; }

04、線程的優先級

1. 線程的最小優先級：1

2. 線程的最大優先級：10

3. 線程的默認優先級：5

4. 通過調用 getPriority() 和 setPriority(int newPriority) 方法來獲得和設置線程的優先級

看下源碼：

/**      * The minimum priority that a thread can have.      */     public final static int MIN_PRIORITY = 1;      /**      * The default priority that is assigned to a thread.      */     public final static int NORM_PRIORITY = 5;      /**      * The maximum priority that a thread can have.      */     public final static int MAX_PRIORITY = 10;

看下代碼：

public class ThreadA extends Thread {      public static void main(String[] args) {         ThreadA a = new ThreadA();         System.out.println(a.getPriority());//5         a.setPriority(8);         System.out.println(a.getPriority());//8     } }

線程優先級特性：

1. 繼承性：比如 A 線程啟動 B 線程，則B線程的優先級與 A 是一樣的。

2. 規則性：高優先級的線程總是大部分先執行完，但不代表高優先級線程全部先執行完。

3. 隨機性：優先級較高的線程不一定每一次都先執行完。

05、線程的停止

1. stop() 方法，這個方法已經標記為過時了，強制停止線程，相當于 kill -9。

2. interrupt() 方法，優雅的停止線程。告訴線程可以停止了，至于線程什么時候停止，取決于線程自身。

看下停止線程的代碼：

public class InterruptDemo {     private static int i ;     public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(() -> {             //默認情況下isInterrupted 返回 false、通過 thread.interrupt 變成了 true             while (!Thread.currentThread().isInterrupted()) {                 i++;             }             System.out.println("Num:" + i);         }, "interruptDemo");         thread.start();         TimeUnit.SECONDS.sleep(1);         thread.interrupt(); //不加這句,thread線程不會停止     } }

看上面這段代碼，主線程 main 方法調用 thread線程的 interrupt() 方法，就是告訴 thread 線程，你可以停止了(其實是將  thread 線程的一個屬性設置為了 true )，然后 thread 線程通過 isInterrupted() 方法獲取這個屬性來判斷是否設置為了  true。這里我再舉一個例子來說明一下，

看代碼：

public class ThreadDemo {     private volatile static Boolean interrupt = false ;     private static int i ;      public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(() -> {             while (!interrupt) {                 i++;             }             System.out.println("Num:" + i);         }, "ThreadDemo");         thread.start();         TimeUnit.SECONDS.sleep(1);         interrupt = true;     } }

是不是很相似，再簡單總結一下：

當其他線程通過調用當前線程的 interrupt  方法，表示向當前線程打個招呼，告訴他可以中斷線程的執行了，并不會立即中斷線程，至于什么時候中斷，取決于當前線程自己。

線程通過檢查自身是否被中斷來進行相應，可以通過 isInterrupted() 來判斷是否被中斷。

這種通過標識符來實現中斷操作的方式能夠使線程在終止時有機會去清理資源，而不是武斷地將線程停止，因此這種終止線程的做法顯得更加安全和優雅。

06、線程的復位

兩種復位方式：

1. Thread.interrupted()

2. 通過拋出 InterruptedException 的方式

然后了解一下什么是復位：

線程運行狀態時 Thread.isInterrupted() 返回的線程狀態是 false，然后調用 thread.interrupt() 中斷線程  Thread.isInterrupted() 返回的線程狀態是 true，最后調用 Thread.interrupted()  復位線程Thread.isInterrupted() 返回的線程狀態是 false 或者拋出 InterruptedException  異常之前，線程會將狀態設為 false。

下面來看下兩種方式復位線程的代碼，首先是 Thread.interrupted() 的方式復位代碼：

public class InterruptDemo {      public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(() -> {             while (true) {                 //Thread.currentThread().isInterrupted()默認是false,當main方式執行thread.interrupt()時,狀態改為true                 if (Thread.currentThread().isInterrupted()) {                     System.out.println("before:" + Thread.currentThread().isInterrupted());//before:true                     Thread.interrupted(); // 對線程進行復位，由 true 變成 false                     System.out.println("after:" + Thread.currentThread().isInterrupted());//after:false                 }             }         }, "interruptDemo");         thread.start();         TimeUnit.SECONDS.sleep(1);         thread.interrupt();     } }

拋出 InterruptedException 復位線程代碼：

public class InterruptedExceptionDemo {      public static void main(String[] args) throws InterruptedException {         Thread thread = new Thread(() -> {             while (!Thread.currentThread().isInterrupted()) {                 try {                     TimeUnit.SECONDS.sleep(1);                 } catch (InterruptedException e) {                     e.printStackTrace();                     // break;                 }             }         }, "interruptDemo");         thread.start();         TimeUnit.SECONDS.sleep(1);         thread.interrupt();         System.out.println(thread.isInterrupted());     } }

結果：

false java.lang.InterruptedException: sleep interrupted     at java.lang.Thread.sleep(Native Method)     at java.lang.Thread.sleep(Thread.java:340)     at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)     at com.cl.concurrentprogram.InterruptedExceptionDemo.lambda$main$0(InterruptedExceptionDemo.java:16)     at java.lang.Thread.run(Thread.java:748)

需要注意的是，InterruptedException  異常的拋出并不意味著線程必須終止，而是提醒當前線程有中斷的操作發生，至于接下來怎么處理取決于線程本身，比如

1. 直接捕獲異常不做任何處理

2. 將異常往外拋出

3. 停止當前線程，并打印異常信息

像我上面的例子,如果拋出 InterruptedException 異常,我就break跳出循環讓 thread 線程終止。

為什么要復位：

Thread.interrupted()  是屬于當前線程的，是當前線程對外界中斷信號的一個響應，表示自己已經得到了中斷信號，但不會立刻中斷自己，具體什么時候中斷由自己決定，讓外界知道在自身中斷前，他的中斷狀態仍然是  false，這就是復位的原因。

以上就是“Java并發編程的基礎知識有哪些”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。