Java 用兩個線程交替打印數字和字母

Posted on by

前一段時間聽馬士兵老師講課，講到某公司的一個面試，兩個線程，其中一個線程輸出ABC，另一個線程輸出123，如何控制兩個線程交叉輸出1A2B3C，由於本人多線程掌握的一直不是很好，所以聽完這道題，個人感覺收獲良多，這是一個學習筆記。這道題有多種解法，不過有些屬於純炫技，所以隻記錄常見的三種解法。首先看第一種

1. park 和 unpark

package cn.bridgeli.demo;
 
import com.google.common.collect.Lists;
 
import java.util.List;
import java.util.concurrent.locks.LockSupport;
 
/**
 * @author BridgeLi
 * @date 2021/2/6 16:14
 */
public class Thread_Communication_Park_Unpark {
 
    static Thread t1 = null;
    static Thread t2 = null;
 
    public static void main(String[] args) {
 
        final List<Integer> integers = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
        final List<String> strings = Lists.newArrayList("A", "B", "C", "D", "E", "F", "G");
 
        t1 = new Thread(() -> integers.forEach(item -> {
            System.out.print(item);
            LockSupport.unpark(t2);
            LockSupport.park();
        }), "t1");
 
        t2 = new Thread(() -> strings.forEach(item -> {
            LockSupport.park();
            System.out.print(item);
            LockSupport.unpark(t1);
        }), "t2");
 
        t1.start();
        t2.start();
    }
 
}

這個是最簡單的實現方法，LockSupport.park() 使當前線程阻塞，而 LockSupport.unpark() 則表示喚醒一個線程，所以他需要一個參數，表示你要喚醒哪個線程，很好理解，也比較簡單。

2. synchronized、notify、wait

package cn.bridgeli.demo;
 
import com.google.common.collect.Lists;
 
import java.util.List;
 
/**
 * @author BridgeLi
 * @date 2021/2/6 16:14
 */
public class Thread_Communication_Notify_Wait {
 
    public static void main(String[] args) {
 
        final Object o = new Object();
        final List<Integer> integers = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
        final List<String> strings = Lists.newArrayList("A", "B", "C", "D", "E", "F", "G");
 
        new Thread(() -> {
            synchronized (o) {
                integers.forEach(item -> {
                    System.out.print(item);
                    o.notify();
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
 
                o.notify();
            }
        }, "t1").start();
 
        new Thread(() -> {
            synchronized (o) {
                strings.forEach(item -> {
                    System.out.print(item);
                    o.notify();
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
                o.notify();
            }
        }, "t2").start();
    }
}

這是一個比較傳統的寫法，也是比較難理解的一個寫法，掌握瞭這種寫法之後，對 synchronized、notify、wait 的認識也會有一個新高度，下面就簡單解析一下這種寫法：

我們都知道 synchronized 是一把鎖，而鎖是什麼？就是一個第三方的互斥的一個資源，所以 synchronized (o)，就表示我們對 o 這個對象加鎖，是通過修改 o 的對象頭實現的，也就是兩個線程誰成功修改瞭 o 的對象頭，那麼誰就拿到瞭這把鎖，然後就可以執行裡面的相關邏輯，而沒有成功修改 o 的對象頭的線程，就隻有進入到對象 o 的一個等待隊列，等待被系統調度執行（這是一個比較簡單的不是很準確說法，詳細過程，等我將來再寫一個文章想聊鎖升級的過程）；然後就是 o.notify()，剛說過 synchronized (o) 一堆線程爭搶鎖，沒有搶到鎖的線程進入對象 o 的等待隊列，所以 o.notify() 含義就是從對象 o 的等待隊列中隨機叫醒一個線程，然後執行；最後是 o.wait() 的含義，他的含義也很簡單，就是當前線程放到對象 o 的等待隊列中，讓出 CPU。

通過這段描述，所以大傢肯定也可以學習到經常遇到的三個問題是怎麼回事：1. wait 是否占用 CPU 資源，因為進入瞭等待隊列，所以是不會占用的；2. 既然 notify、wait 是讓喚醒線程和讓線程進入等待的，為什麼不是 Thread 類的方法，反而是 Object 的方法，因為 notify、wait 是配合 synchronized 一起使用的，不一定用在多線程中，他們控制的是 synchronized 鎖定的對象的等待隊列，而 synchronized 鎖定的對象，肯定是一個 Object，所以 notify、wait 比如是 Object 對象的方法；3. 關於 synchronized (o) 括號裡面是一個對象實例、Class 對象、鎖定代碼塊、靜態變量等等區別，隻要明白 synchronized 修改的是什麼，這些區別就一目瞭然瞭，不再贅述。

最後要說明的一個問題是：循環外邊的 o.notify() 必不可少，有些同學寫的時候可能隨手就忘記瞭，或者不知道為什麼需要最後再 notify 一下，其實仔細想一想就可以明白瞭，假設最後執行的是輸出字母的線程，那麼他之前一定是被執行輸出數字的線程喚醒的，而執行輸出數字的這個線程喚醒執行輸出字母的線程之後，自身就進入等待隊列瞭，所以循環結束之後，如果最後執行輸出字母的線程沒有喚醒執行輸出數字的線程的話，那麼執行輸出數字的線程會一直 wait 阻塞在那裡，將等到天荒地來海枯石爛永遠無法結束。

3. Condition

package cn.bridgeli.demo;
 
import com.google.common.collect.Lists;
 
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * @author BridgeLi
 * @date 2021/2/6 16:14
 */
public class Thread_Communication_Condition {
 
    public static void main(String[] args) {
 
        final List<Integer> integers = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
        final List<String> strings = Lists.newArrayList("A", "B", "C", "D", "E", "F", "G");
 
        Lock lock = new ReentrantLock();
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
 
        new Thread(() -> {
            lock.lock();
            try {
                integers.forEach(item -> {
                    System.out.print(item);
                    condition2.signal();
                    try {
                        condition1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
 
                condition2.signal();
            } finally {
                lock.unlock();
            }
        }, "t1").start();
 
        new Thread(() -> {
            lock.lock();
            try {
                strings.forEach(item -> {
                    System.out.print(item);
                    condition1.signal();
                    try {
                        condition2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
                condition1.signal();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
 
    }
 
}

當我們理解瞭上面兩種寫法之後，那麼最後這個寫法其實也比較容易理解瞭，就不用我多贅言瞭。

如果有幸有同學看到瞭這裡，那麼我再提出一個小問題，可以思考一下怎麼解決，後面兩種寫法，我們保證是執行輸出數字的線程還是執行輸出字母的線程先執行，也就是先輸出數字或者字母嗎？如果不能的話，現在業務需求要求必須是先輸出字母或者數字怎麼做？（提示：CAS 自旋）

以上就是Java 用兩個線程交替打印數字和字母的詳細內容，更多關於Java 線程交替打印的資料請關註WalkonNet其它相關文章！

推薦閱讀：

    None Found