Java線程安全狀態專題解析
一、觀察線程的所有狀態
線程的狀態是一個枚舉類型 Thread.State
public static void main(String[] args) { for (Thread.State state : Thread.State.values()){ System.out.println(state); } }
NEW: 安排瞭工作, 還未開始行動
RUNNABLE: 可工作的. 又可以分成正在工作中和即將開始工作.就緒狀態
BLOCKED: 這幾個都表示排隊等著其他事情
WAITING: 這幾個都表示排隊等著其他事情
TIMED_WAITING: 這幾個都表示排隊等著其他事情
TERMINATED: 工作完成瞭.
二、線程狀態和狀態轉移的意義
NEW:Thread對象有瞭,但是PCB還沒有
RUNNABLE:線程正在CPU上執行或者即將到CPU上執行(PCB在就緒隊列中,隨時可能被調度到)
WAITING:wait方法導致
TIMED_WAITING:sleep方法導致
BLOCKED:等待鎖導致
TERMINATED:對象還在,但PCB已經沒瞭
public static void main(String[] args) { Thread t = new Thread(){ @Override public void run() { for (int i = 0; i < 100_00; i++){ } } }; System.out.println("線程啟動前:" + t.getState()); t.start(); while (t.isAlive()){ System.out.println("線程運行中:" + t.getState()); } System.out.println("線程結束後:" + t.getState()); }
三、多線程帶來的風險
線程不安全的原因
①線程是搶占式執行的
線程不安全的萬惡之源,線程之間的調度完全由內核負責,用戶代碼中感知不到,也無法控制。線程之間誰先執行,誰後執行,誰執行到哪裡從CPU上下來,這樣的過程用戶無法控制也無法感知到的。
②自增操作不是原子的
每次++都能拆成三個步驟
把內存中的數據讀取到CPU中
把CPU中的數據+1
把計算的數據寫回內存中
如果兩個線程串行執行,此時計算結果為2。
如果兩個線程並行執行,線程1進行++操作到一半的時候,線程也進行瞭++操作,此時自增兩次,但結果為1。
必須保證線程1save結束瞭,線程2再load,此時計算結果才正確
③多個線程嘗試修改同一個變量
如果是一個線程修改一個變量,線程安全
如果多個線程讀取同一個變量,線程安全
如果多個線程修改不同的變量。線程安全
④內存可見性導致線程安全問題
⑤指令重排序
Java的編譯器在編譯代碼時,會對指令進行優化,調整指令的先後順序,保證原有的邏輯不變的情況下,提高程序的運行效率
四,解決線程安全問題
鎖-synchronized
未加鎖
static class Counter{ public int count = 0; public void increase(){ count++; } } public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Thread t1 = new Thread(){ @Override public void run() { for (int i = 0; i < 50000; i++){ counter.increase(); } } }; Thread t2 = new Thread(){ @Override public void run() { for (int i = 0; i < 50000; i++){ counter.increase(); } } }; t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(counter.count); }
已加鎖
static class Counter{ public int count = 0; synchronized public void increase(){ count++; } } public static void main(String[] args) throws InterruptedException { Counter counter = new Counter(); Thread t1 = new Thread(){ @Override public void run() { for (int i = 0; i < 50000; i++){ counter.increase(); } } }; Thread t2 = new Thread(){ @Override public void run() { for (int i = 0; i < 50000; i++){ counter.increase(); } } }; t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(counter.count); }
此處的synchronized就是針對counter這個對象來加鎖,進入increase方法內部,就把加鎖狀態設為ture,increase方法退出之後,就把加鎖狀態設為false,如果某個線程已經把加鎖狀態設為ture,此處的其他的線程嘗試去加鎖,就會阻塞
synchronized的特性——刷新內存
synchronized 的工作過程:
1. 獲得互斥鎖
2. 從主內存拷貝變量的最新副本到工作的內存
3. 執行代碼
4. 將更改後的共享變量的值刷新到主內存
5. 釋放互斥鎖
synchronized的特性——互斥
public static void main(String[] args) { Object locker = new Object(); Thread t1 = new Thread(){ @Override public void run() { Scanner scanner = new Scanner(System.in); synchronized (locker) { System.out.println("輸入一個整數"); int num = scanner.nextInt(); System.out.println("num= " + num); } } }; t1.start(); Thread t2 = new Thread(){ @Override public void run() { while (true){ synchronized (locker){ System.out.println("線程2獲取到鎖"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }; t2.start(); }
一旦線程一獲取到鎖,並且沒有釋放的話,線程2就會一直在鎖這裡阻塞等待
public static void main(String[] args) { Object locker1 = new Object(); Object locker2 = new Object(); Thread t1 = new Thread(){ @Override public void run() { Scanner scanner = new Scanner(System.in); synchronized (locker1) { System.out.println("輸入一個整數"); int num = scanner.nextInt(); System.out.println("num= " + num); } } }; t1.start(); Thread t2 = new Thread(){ @Override public void run() { while (true){ synchronized (locker2){ System.out.println("線程2獲取到鎖"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }; t2.start(); }
不是同一把鎖,就不回出現競爭,就沒有互斥瞭。
public static void main(String[] args) { Object locker1 = new Object(); Object locker2 = new Object(); Thread t1 = new Thread(){ @Override public void run() { Scanner scanner = new Scanner(System.in); synchronized (locker1.getClass()) { System.out.println("輸入一個整數"); int num = scanner.nextInt(); System.out.println("num= " + num); } } }; t1.start(); Thread t2 = new Thread(){ @Override public void run() { while (true){ synchronized (locker2.getClass()){ System.out.println("線程2獲取到鎖"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }; t2.start(); }
這個代碼中,兩個線程都在針對locker1和locker2的類對象進行競爭,此處的locker1和locker2的類型都是Object,對應的對象都是相同的對象。
到此這篇關於Java線程安全狀態專題解析的文章就介紹到這瞭,更多相關Java 線程安全內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!