Java線程協作的兩種方式小結

更新時間：2023年05月05日 10:27:32 作者：思維的深度

Java中線程協作的最常見的兩種方式是利用Object.wait()、Object.notify()和使用Condition，本文主要介紹了Java線程協作的兩種方式小結,文中通過示例代碼介紹的非常詳細，需要的朋友們下面隨著小編來一起學習學習吧

為什么線程之間需要協作

線程之間相互配合，完成某項工作，比如：一個線程修改了一個對象的值，而另一個線程感知到了變化，然后進行相應的操作，整個過程開始于一個線程，而最終執(zhí)行又是另一個線程。前者是生產者，后者就是消費者，這種模式隔離了“做什么”（What）和“怎么做”（How）。簡單的辦法是讓消費者線程不斷地循環(huán)檢查變量是否符合預期，在while循環(huán)中設置不滿足的條件，如果條件滿足則退出while循環(huán)，從而完成消費者的工作。這樣進行線程之間的協作卻存在如下2個問題：

（1）難以確保及時性。

（2）難以降低開銷。如果降低睡眠的時間，比如休眠1毫秒，這樣消費者能更加迅速地發(fā)現條件變化，但是卻可能消耗更多的處理器資源，造成了無端的浪費。

那么有沒有什么辦法可以解決以上2個問題呢？此時等待/通知機制毫不客氣的站出來說，都讓開，交給我，我能行！　

介紹

Java中線程協作的最常見的兩種方式：利用Object.wait()、Object.notify()和使用Condition

方法一

Object中的wait、notify、notifyAll方法定義如下

public final native void notify(); public final native void notifyAll(); public final native void wait(long timeout) throws InterruptedException;
wait()、notify()和notifyAll()方法是本地方法，并且為final方法，無法被重寫
調用某個對象的wait()方法能讓當前線程阻塞，并且當前線程必須擁有此對象的monitor（即鎖）
調用某個對象的notify()方法能夠喚醒一個正在等待這個對象的monitor的線程，如果有多個線程都在等待這個對象的monitor，則只能喚醒其中一個線程
調用notifyAll()方法能夠喚醒所有正在等待這個對象的monitor的線程
之所以這三個方法聲明在Object類中是因為每個對象都擁有monitor（即鎖）
調用某個對象的wait()方法，當前線程必須擁有這個對象的monitor（即鎖），因此調用wait()方法必須在同步塊或者同步方法中進行

示例

public class Test {
    public static Object object = new Object();
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
    static class Thread1 extends Thread{
        @Override
        public void run() {
            synchronized (object) {
                try {
                    object.wait();
                } catch (InterruptedException e) {
                }
                System.out.println("線程"+Thread.currentThread().getName()+"獲取到了鎖");
            }
        }
    }
    static class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized (object) {
                object.notify();
                System.out.println("線程"+Thread.currentThread().getName()+"調用了object.notify()");
            }
            System.out.println("線程"+Thread.currentThread().getName()+"釋放了鎖");
        }
    }
}

運行結果

線程Thread-1調用了object.notify()
線程Thread-1釋放了鎖
線程Thread-0獲取到了鎖

方法二

Condition是在java 1.5中才出現的，它用來替代傳統(tǒng)的Object的wait()、notify()實現線程間的協作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()這種方式實現線程間協作更加安全和高效
Condition是個接口，基本的方法就是await()和signal()方法
Condition依賴于Lock接口，生成一個Condition的基本代碼是lock.newCondition()
調用Condition的await()和signal()方法，都必須在lock保護之內，就是說必須在lock.lock()和lock.unlock之間才可以使用

示例

public class Test {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();
    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();
        producer.start();
        consumer.start();
    }
    class Consumer extends Thread{
        @Override
        public void run() {
            consume();
        }
        private void consume() {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == 0){
                        try {
                            System.out.println("隊列空，等待數據");
                            notEmpty.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.poll();                //每次移走隊首元素
                    notFull.signal();
                    System.out.println("從隊列取走一個元素，隊列剩余"+queue.size()+"個元素");
                } finally{
                    lock.unlock();
                }
            }
        }
    }
    class Producer extends Thread{
        @Override
        public void run() {
            produce();
        }
        private void produce() {
            while(true){
                lock.lock();
                try {
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("隊列滿，等待有空余空間");
                            notFull.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.offer(1);        //每次插入一個元素
                    notEmpty.signal();
                    System.out.println("向隊列取中插入一個元素，隊列剩余空間："+(queueSize-queue.size()));
                } finally{
                    lock.unlock();
                }
            }
        }
    }
}

到此這篇關于Java線程協作的兩種方式小結的文章就介紹到這了,更多相關Java線程協作內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: