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線程協作的方式有哪些的詳細內容。更多資訊請關注PHP中文網其他相關文章！