Java線程協作的方式有哪些

本篇內容介紹了“Java線程協作的方式有哪些”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

為什么線程之間需要協作

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

（1）難以確保及時性。

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

介紹

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中才出現的，它用來替代傳統的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線程協作的方式有哪些”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！