Java中如何實現線程通信

今天就跟大家聊聊有關Java中如何實現線程通信，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

1、synchronized加wait/notify方式

/**
 * wait和notify的使用
 * wait和notify必須應用在synchronized塊或方法內
 * 下面的代碼向跳交誼舞一樣互相控制著對方的輸出
 */
public class MutiThread_WaitNotify {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (lock){
                    try{
                        lock.wait();
                        System.out.println("A-1");
                        lock.notify();
                        lock.wait();
                        System.out.println("A-2");
                        lock.notify();
                        lock.wait();
                        System.out.println("A-3");
                        lock.notify();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread b = new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (lock){
                    try{
                        System.out.println("B-1");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-2");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-3");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-4");
                    }catch(InterruptedException e){
                        e.printStackTrace();;
                    }
                }
            }
        });
        a.start();
        b.start();
    }
}

2、ReentrantLock加Condition方式

/**
 * ReentrantLock和Condition的使用
 * 在使用Conditioin的await和signal時，必須將這兩個方法寫在ReentrantLock的lock方法之后
 */
public class MutiThread_ReentrantLock_Condition {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        int i=1;
        for(; i<=6; i++){
            final int k = i;
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        lock.lock();
                        System.out.println("ThreadNo:A" + k + " is locked");
                        // 通過condition.await將線程阻塞
                        condition.await();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }finally{
                        lock.unlock();
                        System.out.println("ThreadNo:A"+k + " is unlocked");
                    }
                }
            });

            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    if(k == 6){
                        try{
                            lock.lock();
                            System.out.println("All Threads is signaled");
                            // 通過condition.signalAll喚醒所有線程
                            condition.signalAll();
                        }catch(Exception e){
                            e.printStackTrace();
                        }finally{
                            lock.unlock();
                        }
                    }else{
                        System.out.println("threads can't signaled, wait a moment.");
                    }
                }
            });
            t1.start();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
        }
    }
}

3、閉鎖方式

import java.util.concurrent.CountDownLatch;
/**
 * 閉鎖的使用
 * 閉鎖用于等待事件，當閉鎖到達結束狀態（本例中是閉鎖的計數器值減為0）之前，所有線程都等待，當閉鎖到達結束狀態時，所有線程都通過
 * 閉鎖是一次性的，當閉鎖到達結束狀態后，將不會被重置，這個鎖會永遠打開并允許所有線程通過。
 * 可以將代碼中的NUM變量值變為2和4，分別試試什么效果
 */
public class MutiThread_CountDownLatch {
    public static void main(String[] args) {
        // 定義閉鎖，并設置閉鎖的計數器值為3
        CountDownLatch lock = new CountDownLatch(3);
        // 循環定義3個線程
        int NUM = 3;
        for(int i=1; i<=NUM; i++){
            final int k = i;
            Thread a = new Thread(new Runnable(){
                @Override
                public void run(){
                    try{
                        Thread.sleep(k * 1000);
                        System.out.println("ThreadNo:A"+k);
                        // 每個線程在休眠指定時間后將閉鎖的計數器值減1，當閉鎖的計數器值減到0時，閉所將被打開，從而使第二個循環中的所有線程才能通過
                        lock.countDown();
                        // 打印閉鎖計數器的值
                        System.out.println("ThreadNo:A"+k+"; getCount:"+lock.getCount());
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            a.start();
        }
        // 循環定義2個線程
        for(int i=1; i<=2; i++){
            final int k = i;
            Thread b = new Thread(new Runnable(){
                @Override
                public void run(){
                    try{
                        System.out.println("ThreadNo:B"+k+" is waiting...");
                        // 當閉鎖的計數器值不為0時，線程將在此處被中斷
                        lock.await();
                        // 當閉鎖的計數器值等于0時，閉鎖將被打開，所有等待的線程都將被喚醒
                        System.out.println("ThreadNo:B"+k+" is notify");
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            b.start();
        }
    }
}

4、柵欄的方式

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 柵欄的使用
 * 柵欄用于等待線程，所有線程必須同時到達柵欄，才能繼續執行
 * 柵欄不是一次性的，可以被重置。
 * 可以將代碼中的NUM變量值變為5和7，分別試試什么效果
 */
public class MutiThread_CyclicBarrier {
    public static void main(String[] args) {
        // 定義柵欄，并設置柵欄需要等待的線程數為6
        CyclicBarrier barrier = new CyclicBarrier(6);
        int NUM = 100;
        for(int i=1; i<=NUM; i++){
            final int k = i;
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        Thread.sleep(k * 1000);
                        System.out.println("ThreadNo:"+k+" is waiting, getNumberWaiting:" + barrier.getNumberWaiting());
                        // 柵欄設置的等待線程數為6，當線程數不夠6個時,所有線程將在此等待
                        barrier.await();
                        // 當線程數達到6個時，柵欄將被打開，所有線程都將被喚醒
                        System.out.println("ThreadNo:"+k+" is notify");
                        // 柵欄被重置，以便下次繼續使用
                        barrier.reset();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}

5、信號量的方式

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;

/**
 * 信號量的使用
 * 信號量用于控制同時訪問某個資源的線程數量，信號量還可以用于實現某個資源池。
 * 信號量管理者一組虛擬的許可，線程在執行操作時首先要獲得許可，如果信號量的許可數量為0，那么accquire將阻塞直到有許可為止
 * 信號量不是一次性的，當信號鏈的許可用完之后，可以通過release釋放許可
 */
public class MutiThread_Semaphore {
    public static void main(String[] args) {
        // 定義信號量，并設置信號量的允許發放的最大許可數量為6
        final Semaphore semaphore = new Semaphore(6);
        // 定義集合，當信號量未發放的許可數量大于0則允許線程向集合內添加元素
        final List<String> set = new ArrayList<>();
        int i = 1;
        while(true){
            final int k = i++;
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    boolean res = false;
                    try{
                        System.out.println("ThreadNo:A"+k+", availablePermits:"+semaphore.availablePermits());
                        // 當信號量允許發放的許可數量大于0，則會向集合內添加元素，否則將被中斷于此
                        semaphore.acquire();
                        res = set.add("1");
                        System.out.println("ThreadNo:A"+k+" add item success");
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }finally{
                        if(!res){
                            semaphore.release();
                        }
                    }
                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    if(semaphore.availablePermits() == 0){
                        // 如果信號量允許發放的許可數量等于0，則釋放制定數量的許可
                        semaphore.release(3); //釋放3個許可
                        System.out.println("ThreadNo:B"+k+" releasePermitNum:"+semaphore.availablePermits());
                    }
                }
            });
            t.start();
            t2.start();
            System.out.println("the num of set:"+set.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

A、join的使用

/**
 * join的使用
 * 實現當調用join的線程執行完畢后，其他線程才能執行
 */
public class MutiThread_Join {
    public static void main(String[] args) {
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                printNumber("A");
            }
        });
        Thread b = new Thread(new Runnable(){
            @Override
            public void run(){
                printNumber("B");
            }
        });
        try{
            a.start();
            // a線程執行完畢后，b線程才能執行
            a.join();
            b.start();
        }catch(InterruptedException e){
            e.printStackTrace();;
        }
    }
    public static void printNumber(String s){
        System.out.println(s+" print:"+s);
    }
}

B、yield的使用

/**
 * yield，當一個線程中調用了這個方法后，這個線程就會把自己的CPU執行時間讓給自己或其它線程，
 * 注意是讓給自己或其它線程，并不是單純讓給其他線程。yield執行后，能讓當前線程由運行狀態
 * 進入到就緒狀態，將自己的CPU時間片讓出來，讓出來之后有可能是其它線程執行，也有可能是該線程
 * 繼續執行。優先級高的線程并不一定是首先執行，而是首先執行的概率會高一些。優先級在大量線程
 * 執行的時候才能體現的出來。
 */
public class MutiThread_yield {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("ThreadNo:A"+i);
                    Thread.yield();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("ThreadNo:B"+i);
                    Thread.yield();
                }
            }
        });
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

看完上述內容，你們對Java中如何實現線程通信有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。