Java線程中的關鍵字和方法示例詳解

更新時間：2022年03月02日 10:38:34 作者：/少司命

這篇文章主要介紹了Java有關線程中的關鍵字和方法,本文通過示例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下

一、volatile關鍵字

1，volatile 能保證內存可見性

代碼在寫入 volatile 修飾的變量的時候

        改變線程工作內存中volatile變量副本的值

        將改變后的副本的值從工作內存刷新到主內存

代碼在讀取 volatile 修飾的變量的時候

        從主內存中讀取volatile變量的最新值到線程的工作內存中

        從工作內存中讀取volatile變量的副本

 static class Counter{
        public int flag = 0;
    }
    
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                while (counter.flag == 0){
 
                }
                System.out.println("循環(huán)結束");
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("請輸入一個整數(shù)：");
                counter.flag = scanner.nextInt();
        t2.start();

預期的結果是：

線程1會先進入循環(huán)狀態(tài)，線程2讀取一個用戶輸入的整數(shù)。隨著用戶的輸入一個非0的整數(shù)之后，線程1就會終止。

實際效果：

線程2輸入完畢后，線程1循環(huán)并未結束

2，編譯器優(yōu)化問題

線程1的核心代碼中，循環(huán)其實啥也沒干，反復快速的執(zhí)行循環(huán)條件中的比較操作。

先從內存中讀取flag的值到CPU中

在CPU中比較這個值和0的關系

編譯器判定這個邏輯中循環(huán)沒有干啥事，只是頻繁的讀取內存而已，于是編譯器就把讀內存的操作優(yōu)化了，第一次把內存中的數(shù)據(jù)督讀到CPU之后，后序的內存并不是真正的從內存中讀，而是直接從剛在的CPU中讀數(shù)據(jù)

編譯器認為flag沒有改動，其實只是在當前線程中沒有改動，編譯器就不能感知到其他的線程對flag進行了修改

static class Counter{
        public  volatile  int flag = 0;
    }
 
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                while (counter.flag == 0){
                }
                System.out.println("循環(huán)結束");
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("請輸入一個整數(shù)：");
                counter.flag = scanner.nextInt();
        t2.start();

加了volatile之后，對這個內存的讀取操作肯定是從內存中來讀

不加volatile的時候，讀取操作可能不是從內存中讀取，從CPU上讀取舊值，這都是不確定的

volatile 和 synchronized 有著本質的區(qū)別.

synchronized 能夠保證原子性, volatile 保證的是內存可見性

synchronized 既能保證原子性, 也能保證內存可見性.

二、wait 和 notify

由于線程之間是搶占式執(zhí)行的, 因此線程之間執(zhí)行的先后順序難以預知. 但是實際開發(fā)中有時候我們希望合理的協(xié)調多個線程之間的執(zhí)行先后順序

1，wait()方法

wait 做的事情:

使當前執(zhí)行代碼的線程進行等待. (把線程放到等待隊列中)

釋放當前的鎖

滿足一定條件時被喚醒, 重新嘗試獲取這個鎖.

wait 要搭配 synchronized 來使用. 脫離 synchronized 使用 wait 會直接拋出異常.

wait 結束等待的條件:

其他線程調用該對象的 notify 方法.

wait 等待時間超時 (wait 方法提供一個帶有 timeout 參數(shù)的版本, 來指定等待時間).

其他線程調用該等待線程的 interrupted 方法, 導致 wait 拋出 InterruptedException 異常.

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object){
            System.out.println("等待前");
            object.wait();
            System.out.println("等待后");
        }
    }

就相當于一個人去ATM上取錢，發(fā)現(xiàn)ATM中沒錢，然后阻塞等待（不參與后續(xù)鎖的競爭）——wait

等到銀行的工作人員來送錢，你可以取錢了——notify

2，notify()方法

notify 方法是喚醒等待的線程.

        方法notify()也要在同步方法或同步塊中調用，該方法是用來通知那些可能等待該對象的對象鎖的其它線程，對其發(fā)出通知notify，并使它們重新獲取該對象的對象鎖。

        如果有多個線程等待，則有線程調度器隨機挑選出一個呈 wait 狀態(tài)的線程。(并沒有 "先來后到")

        在notify()方法后，當前線程不會馬上釋放該對象鎖，要等到執(zhí)行notify()方法的線程將程序執(zhí)行完，也就是退出同步代碼塊之后才會釋放對象鎖。

 public static void main(String[] args) {
        Object locker = new Object();
 
        Thread t1 = new Thread(){
            @Override
            public void run() {
                synchronized (locker){
                    while (true){
                        System.out.println("wait開始");
                        try {
                            locker.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("wait結束");
                    }
                }
            }
        };
        t1.start();
        Thread t2 = new Thread(){
                Scanner scanner = new Scanner(System.in);
                System.out.println("輸入一個整數(shù)，繼續(xù)執(zhí)行");
                int num = scanner.nextInt();
                    System.out.println("notify開始");
                    locker.notify();
                    System.out.println("notify結束");
        t2.start();
    }