怎么在Java中使用線程交替打印數(shù)字和字母

今天就跟大家聊聊有關(guān)怎么在Java中使用線程交替打印數(shù)字和字母，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結(jié)了以下內(nèi)容，希望大家根據(jù)這篇文章可以有所收獲。

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();
    }
 
}

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

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();
    }
}

這是一個比較傳統(tǒng)的寫法，也是比較難理解的一個寫法，掌握了這種寫法之后，對 synchronized、notify、wait 的認(rèn)識也會有一個新高度，下面就簡單解析一下這種寫法：

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

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

最后要說明的一個問題是：循環(huán)外邊的 o.notify() 必不可少，有些同學(xué)寫的時候可能隨手就忘記了，或者不知道為什么需要最后再 notify 一下，其實仔細(xì)想一想就可以明白了，假設(shè)最后執(zhí)行的是輸出字母的線程，那么他之前一定是被執(zhí)行輸出數(shù)字的線程喚醒的，而執(zhí)行輸出數(shù)字的這個線程喚醒執(zhí)行輸出字母的線程之后，自身就進(jìn)入等待隊列了，所以循環(huán)結(jié)束之后，如果最后執(zhí)行輸出字母的線程沒有喚醒執(zhí)行輸出數(shù)字的線程的話，那么執(zhí)行輸出數(shù)字的線程會一直 wait 阻塞在那里，將等到天荒地來?？菔癄€永遠(yuǎn)無法結(jié)束。

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();
 
    }
 
}

看完上述內(nèi)容，你們對怎么在Java中使用線程交替打印數(shù)字和字母有進(jìn)一步的了解嗎？如果還想了解更多知識或者相關(guān)內(nèi)容，請關(guān)注億速云行業(yè)資訊頻道，感謝大家的支持。