2. 程式人生 > >【Java】生產者消費者模式的實現

【Java】生產者消費者模式的實現

阿新 • • 發佈：2019-01-27

前言

生產者消費者問題是執行緒模型中的經典問題：生產者和消費者在同一時間段內共用同一儲存空間，生產者向空間裡生產資料，而消費者取走資料。

阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。這個阻塞佇列就是用來給生產者和消費者解耦的。

wait/notify方法

首先，我們搞清楚Thread.sleep()方法和Object.wait()、Object.notify()方法的區別。根據這篇文章java sleep和wait的區別的疑惑?

  1. sleep()是Thread類的方法；而wait()，notify()，notifyAll()是Object類中定義的方法；儘管這兩個方法都會影響執行緒的執行行為，但是本質上是有區別的。

  2. Thread.sleep()不會導致鎖行為的改變，如果當前執行緒是擁有鎖的，那麼Thread.sleep()不會讓執行緒釋放鎖。如果能夠幫助你記憶的話，可以簡單認為和鎖相關的方法都定義在Object類中，因此呼叫Thread.sleep()是不會影響鎖的相關行為。

  3. Thread.sleep和Object.wait都會暫停當前的執行緒，對於CPU資源來說，不管是哪種方式暫停的執行緒，都表示它暫時不再需要CPU的執行時間。OS會將執行時間分配給其它執行緒。區別是呼叫wait後，需要別的執行緒執行notify/notifyAll才能夠重新獲得CPU執行時間。

執行緒狀態圖：

  • Thread.sleep()
    讓執行緒從 【running】 -> 【阻塞態】 時間結束/interrupt -> 【runnable】
  • Object.wait()讓執行緒從 【running】 -> 【等待佇列】notify -> 【鎖池】 -> 【runnable】

實現生產者消費者模型

生產者消費者問題是研究多執行緒程式時繞不開的經典問題之一，它描述是有一塊緩衝區作為倉庫，生產者可以將產品放入倉庫，消費者則可以從倉庫中取走產品。在Java中一共有四種方法支援同步，其中前三個是同步方法，一個是管道方法。

（1）Object的wait() / notify()方法
（2）Lock和Condition

的await() / signal()方法
（3）BlockingQueue阻塞佇列方法
（4）PipedInputStream / PipedOutputStream

本文只介紹最常用的前三種，第四種暫不做討論。原始碼在這裡：Java實現生產者消費者模型

1. 使用Object的wait() / notify()方法

wait()/ nofity()方法是基類Object的兩個方法，也就意味著所有Java類都會擁有這兩個方法，這樣，我們就可以為任何物件實現同步機制。

  • wait()：當緩衝區已滿/空時，生產者/消費者執行緒停止自己的執行，放棄鎖，使自己處於等待狀態，讓其他執行緒執行。
  • notify()：當生產者/消費者向緩衝區放入/取出一個產品時，向其他等待的執行緒發出可執行的通知，同時放棄鎖，使自己處於等待狀態。
/**
 * 生產者消費者模式：使用Object.wait() / notify()方法實現
 */
public class ProducerConsumer {
    private static final int CAPACITY = 5;

    public static void main(String args[]){
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new Producer("P-1", queue, CAPACITY);
        Thread producer2 = new Producer("P-2", queue, CAPACITY);
        Thread consumer1 = new Consumer("C1", queue, CAPACITY);
        Thread consumer2 = new Consumer("C2", queue, CAPACITY);
        Thread consumer3 = new Consumer("C3", queue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

    /**
     * 生產者
     */
    public static class Producer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;
        int i = 0;

        public Producer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                synchronized(queue){
                    while(queue.size() == maxSize){
                        try {
                            System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                            queue.wait();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                    System.out.println("[" + name + "] Producing value : +" + i);
                    queue.offer(i++);
                    queue.notifyAll();

                    try {
                        Thread.sleep(new Random().nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

    /**
     * 消費者
     */
    public static class Consumer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;

        public Consumer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                synchronized(queue){
                    while(queue.isEmpty()){
                        try {
                            System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                            queue.wait();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                    int x = queue.poll();
                    System.out.println("[" + name + "] Consuming value : " + x);
                    queue.notifyAll();

                    try {
                        Thread.sleep(new Random().nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
注意要點

判斷Queue大小為0或者大於等於queueSize時須使用 while (condition) {}，不能使用 if(condition) {}。其中 while(condition)迴圈，它又被叫做“自旋鎖”。自旋鎖以及wait()和notify()方法在執行緒通訊這篇文章中有更加詳細的介紹。為防止該執行緒沒有收到notify()呼叫也從wait()中返回（也稱作虛假喚醒），這個執行緒會重新去檢查condition條件以決定當前是否可以安全地繼續執行還是需要重新保持等待，而不是認為執行緒被喚醒了就可以安全地繼續執行了。

輸出日誌如下：

[P-1] Producing value : +0
[P-1] Producing value : +1
[P-1] Producing value : +2
[P-1] Producing value : +3
[P-1] Producing value : +4
Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.
[C3] Consuming value : 0
[C3] Consuming value : 1
[C3] Consuming value : 2
[C3] Consuming value : 3
[C3] Consuming value : 4
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +0
[C1] Consuming value : 0
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +5
[P-1] Producing value : +6
[P-1] Producing value : +7
[P-1] Producing value : +8
[P-1] Producing value : +9
Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.
[C3] Consuming value : 5
[C3] Consuming value : 6
[C3] Consuming value : 7
[C3] Consuming value : 8
[C3] Consuming value : 9
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +1
[C1] Consuming value : 1
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +10
[P-1] Producing value : +11
[P-1] Producing value : +12
[P-1] Producing value : +13
[P-1] Producing value : +14
Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.
[C3] Consuming value : 10
[C3] Consuming value : 11
[C3] Consuming value : 12
[C3] Consuming value : 13
[C3] Consuming value : 14
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +2
[P-2] Producing value : +3
[P-2] Producing value : +4
[P-2] Producing value : +5
[P-2] Producing value : +6
Queue is full, Producer[P-2] thread waiting for consumer to take something from queue.
[C1] Consuming value : 2
[C1] Consuming value : 3
[C1] Consuming value : 4
[C1] Consuming value : 5
[C1] Consuming value : 6
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +15
[C3] Consuming value : 15
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +7
[P-2] Producing value : +8
[P-2] Producing value : +9

2. 使用Lock和Condition的await() / signal()方法

在JDK5.0之後，Java提供了更加健壯的執行緒處理機制，包括同步、鎖定、執行緒池等，它們可以實現更細粒度的執行緒控制。Condition介面的await()和signal()就是其中用來做同步的兩種方法，它們的功能基本上和Object的wait()/ nofity()相同，完全可以取代它們，但是它們和新引入的鎖定機制Lock直接掛鉤，具有更大的靈活性。通過在Lock物件上呼叫newCondition()方法，將條件變數和一個鎖物件進行繫結，進而控制併發程式訪問競爭資源的安全。下面來看程式碼：

/**
 * 生產者消費者模式：使用Lock和Condition實現
 * {@link java.util.concurrent.locks.Lock}
 * {@link java.util.concurrent.locks.Condition}
 */
public class ProducerConsumerByLock {
    private static final int CAPACITY = 5;
    private static final Lock lock = new ReentrantLock();
    private static final Condition fullCondition = lock.newCondition();     //佇列滿的條件
    private static final Condition emptyCondition = lock.newCondition();        //佇列空的條件


    public static void main(String args[]){
        Queue<Integer> queue = new LinkedList<Integer>();

        Thread producer1 = new Producer("P-1", queue, CAPACITY);
        Thread producer2 = new Producer("P-2", queue, CAPACITY);
        Thread consumer1 = new Consumer("C1", queue, CAPACITY);
        Thread consumer2 = new Consumer("C2", queue, CAPACITY);
        Thread consumer3 = new Consumer("C3", queue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

    /**
     * 生產者
     */
    public static class Producer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;
        int i = 0;

        public Producer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){

                //獲得鎖
                lock.lock();
                while(queue.size() == maxSize){
                    try {
                        System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");
                        //條件不滿足，生產阻塞
                        fullCondition.await();
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("[" + name + "] Producing value : +" + i);
                queue.offer(i++);

                //喚醒其他所有生產者、消費者
                fullCondition.signalAll();
                emptyCondition.signalAll();

                //釋放鎖
                lock.unlock();

                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 消費者
     */
    public static class Consumer extends Thread{
        private Queue<Integer> queue;
        String name;
        int maxSize;

        public Consumer(String name, Queue<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.queue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                //獲得鎖
                lock.lock();

                while(queue.isEmpty()){
                    try {
                        System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");
                        //條件不滿足，消費阻塞
                        emptyCondition.await();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                int x = queue.poll();
                System.out.println("[" + name + "] Consuming value : " + x);

                //喚醒其他所有生產者、消費者
                fullCondition.signalAll();
                emptyCondition.signalAll();

                //釋放鎖
                lock.unlock();

                try {
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

輸入日誌如下：

[P-1] Producing value : +0
[C1] Consuming value : 0
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-2] Producing value : +0
[C3] Consuming value : 0
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +1
[C2] Consuming value : 1
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +1
[C1] Consuming value : 1
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +2
[C3] Consuming value : 2
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-2] Producing value : +2
[C2] Consuming value : 2
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-1] Producing value : +3
[C1] Consuming value : 3
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-2] Producing value : +3
[C2] Consuming value : 3
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-1] Producing value : +4
[C1] Consuming value : 4
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +4
[C3] Consuming value : 4
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +5
[C2] Consuming value : 5
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-1] Producing value : +5
[C1] Consuming value : 5
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-2] Producing value : +6
[C2] Consuming value : 6
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +6
[C3] Consuming value : 6
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-2] Producing value : +7
[C3] Consuming value : 7
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-1] Producing value : +7
[C1] Consuming value : 7
Queue is empty, Consumer[C2] thread is waiting for Producer
[P-2] Producing value : +8
[C2] Consuming value : 8
[P-1] Producing value : +8
[C1] Consuming value : 8
[P-2] Producing value : +9
[C3] Consuming value : 9
[P-2] Producing value : +10
[C2] Consuming value : 10
[P-1] Producing value : +9
[P-1] Producing value : +10
[C1] Consuming value : 9
[P-2] Producing value : +11
[C3] Consuming value : 10
[C2] Consuming value : 11
[P-2] Producing value : +12
[C1] Consuming value : 12
[P-1] Producing value : +11
[C3] Consuming value : 11
[P-2] Producing value : +13
[C2] Consuming value : 13
Queue is empty, Consumer[C2] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +12
[C2] Consuming value : 12
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-1] Producing value : +13
[C3] Consuming value : 13
Queue is empty, Consumer[C1] thread is waiting for Producer
Queue is empty, Consumer[C3] thread is waiting for Producer
[P-2] Producing value : +14
[C1] Consuming value : 14
Queue is empty, Consumer[C3] thread is waiting for Producer
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-1] Producing value : +14
[C3] Consuming value : 14
Queue is empty, Consumer[C1] thread is waiting for Producer
[P-1] Producing value : +15
[C1] Consuming value : 15
[P-2] Producing value : +15
[P-1] Producing value : +16
[C3] Consuming value : 15
[P-2] Producing value : +16

3. 使用BlockingQueue阻塞佇列方法

JDK 1.5 以後新增的 java.util.concurrent包新增了 BlockingQueue 介面。並提供瞭如下幾種阻塞佇列實現：

  • java.util.concurrent.ArrayBlockingQueue
  • java.util.concurrent.LinkedBlockingQueue
  • java.util.concurrent.SynchronousQueue
  • java.util.concurrent.PriorityBlockingQueue

實現生產者-消費者模型使用 ArrayBlockingQueue或者 LinkedBlockingQueue即可。

我們這裡使用LinkedBlockingQueue，它是一個已經在內部實現了同步的佇列，實現方式採用的是我們第2種await()/ signal()方法。它可以在生成物件時指定容量大小。它用於阻塞操作的是put()和take()方法。

  • put()方法：類似於我們上面的生產者執行緒，容量達到最大時，自動阻塞。
  • take()方法：類似於我們上面的消費者執行緒，容量為0時，自動阻塞。

我們可以跟進原始碼看一下LinkedBlockingQueue類的put()方法實現：

/** Main lock guarding all access */
final ReentrantLock lock = new ReentrantLock();

/** Condition for waiting takes */
private final Condition notEmpty = lock.newCondition();

/** Condition for waiting puts */
private final Condition notFull = lock.newCondition();



public void put(E e) throws InterruptedException {
    putLast(e);
}

public void putLast(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        while (!linkLast(node))
            notFull.await();
    } finally {
        lock.unlock();
    }
}

看到這裡證實了它的實現方式採用的是我們第2種await()/ signal()方法。下面我們就使用它實現吧。

/**
 * 生產者消費者模式：使用{@link java.util.concurrent.BlockingQueue}實現
 */
public class ProducerConsumerByBQ{
    private static final int CAPACITY = 5;

    public static void main(String args[]){
        LinkedBlockingDeque<Integer> blockingQueue = new LinkedBlockingDeque<Integer>(CAPACITY);

        Thread producer1 = new Producer("P-1", blockingQueue, CAPACITY);
        Thread producer2 = new Producer("P-2", blockingQueue, CAPACITY);
        Thread consumer1 = new Consumer("C1", blockingQueue, CAPACITY);
        Thread consumer2 = new Consumer("C2", blockingQueue, CAPACITY);
        Thread consumer3 = new Consumer("C3", blockingQueue, CAPACITY);

        producer1.start();
        producer2.start();
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }

    /**
     * 生產者
     */
    public static class Producer extends Thread{
        private LinkedBlockingDeque<Integer> blockingQueue;
        String name;
        int maxSize;
        int i = 0;

        public Producer(String name, LinkedBlockingDeque<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.blockingQueue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                try {
                    blockingQueue.put(i);
                    System.out.println("[" + name + "] Producing value : +" + i);
                    i++;

                    //暫停最多1秒
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 消費者
     */
    public static class Consumer extends Thread{
        private LinkedBlockingDeque<Integer> blockingQueue;
        String name;
        int maxSize;

        public Consumer(String name, LinkedBlockingDeque<Integer> queue, int maxSize){
            super(name);
            this.name = name;
            this.blockingQueue = queue;
            this.maxSize = maxSize;
        }

        @Override
        public void run(){
            while(true){
                try {
                    int x = blockingQueue.take();
                    System.out.println("[" + name + "] Consuming : " + x);

                    //暫停最多1秒
                    Thread.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

輸出日誌如下：

[P-2] Producing value : +0
[P-1] Producing value : +0
[C1] Consuming : 0
[C3] Consuming : 0
[P-2] Producing value : +1
[C2] Consuming : 1
[P-2] Producing value : +2
[C1] Consuming : 2
[P-1] Producing value : +1
[C2] Consuming : 1
[P-1] Producing value : +2
[C3] Consuming : 2
[P-1] Producing value : +3
[C2] Consuming : 3
[P-2] Producing value : +3
[C1] Consuming : 3
[P-1] Producing value : +4
[C2] Consuming : 4
[P-2] Producing value : +4
[C3] Consuming : 4
[P-2] Producing value : +5
[C1] Consuming : 5
[P-1] Producing value : +5
[C2] Consuming : 5
[P-1] Producing value : +6
[C1] Consuming : 6
[P-2] Producing value : +6
[C2] Consuming : 6
[P-2] Producing value : +7
[C2] Consuming : 7
[P-1] Producing value : +7
[C1] Consuming : 7
[P-2] Producing value : +8
[C3] Consuming : 8
[P-2] Producing value : +9
[C2] Consuming : 9
[P-1] Producing value : +8
[C2] Consuming : 8
[P-2] Producing value : +10
[C1] Consuming : 10
[P-1] Producing value : +9
[C3] Consuming : 9
[P-1] Producing value : +10
[C2] Consuming : 10
[P-2] Producing value : +11
[C1] Consuming : 11
[C3] Consuming : 12
[P-2] Producing value : +12
[P-2] Producing value : +13
[C2] Consuming : 13
[P-1] Producing value : +11
[C3] Consuming : 11
[P-1] Producing value : +12
[C3] Consuming : 12
[P-2] Producing value : +14
[C1] Consuming : 14
[P-1] Producing value : +13
[C2] Consuming : 13
[P-2] Producing value : +15
[C3] Consuming : 15
[P-2] Producing value : +16
[C1] Consuming : 16
[P-1] Producing value : +14
[C3] Consuming : 14
[P-2] Producing value : +17
[C2] Consuming : 17

參考資料

相關推薦

【Java】生產者消費者模式的實現

前言 生產者消費者問題是執行緒模型中的經典問題：生產者和消費者在同一時間段內共用同一儲存空間，生產者向空間裡生產資料，而消費者取走資料。 阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。這個阻塞佇列就是用來給生產者和消費者解耦的。 wa

【Linux】生產者消費者程式設計實現-執行緒池+訊號量

生產者消費者程式設計實現，採用了執行緒池以及訊號量技術。 執行緒的概念就不多說，首先說一下多執行緒的好處：多執行緒技術主要解決處理器單元內多個執行緒執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。 那麼為什麼又需要執行緒池呢？ 我們知道應

【Java併發】生產者-消費者模式簡單實現（模擬訊息佇列）

簡單的模擬了一個訊息佇列 Producer：生產者 Consumer：消費者 Message：訊息體 import java.util.concurrent.ArrayBlockingQueue; import java.util.c

java——利用生產者消費者模式思想實現簡易版handler機制

參考教程：http://www.sohu.com/a/237792762_659256 首先介紹每一個類： 1.Message： 　　這個類的作用是儲存一個生產者生產出來的具體的訊息，就類似連結串列佇列中的一個節點，自行定義需要儲存的內容。 　　code：訊息要執行的具體動作程式碼 　　msg：訊息

Java多執行緒學習筆記(九) 生產者/消費者模式實現

1. 一個生產者和一個消費者：操作值 1.1 公共值 public class ValueObject { public static String value = ""; } 1.2 生產者 public class Producer {

【Java】Swing+IO流實現一個簡單的文件加密程序

als oncommand override fault 源文件 abs directory imp select EncrytService package com.my.service; import java.io.File; import java

【Java】Swing+IO流實現一個簡單的文件加密程序（較完整版）

move 初始 baidu images 文件選擇器 while login 一個 ktr 留著參考 beans package com.my.bean; import java.io.Serializable; public class

生產者-消費者模式實現

java 生產者 消費者 生產者是指：生產數據的線程消費者是指：使用數據的線程生產者和消費者是不同的線程，他們處理數據的速度是不一樣的，一般在二者之間還要加個“橋梁參與者”，用於緩沖二者之間處理數據的速度差。下面用代碼來說明：//生產者 public class MakerThread ex

多線程生產者/消費者模式實現

als true not eat bre creat 測試類 void group 參考書籍《java多線程編程核心技術》 都是基於wait/notify實現的 一個生產者和一個消費者：操作值 1 package com.qf.test10.pojo; 2

【Java】使用Atomic變數實現鎖

Atomic原子操作 Java從JDK1.5開始提供了java.util.concurrent.atomic包，方便程式設計師在多執行緒環境下，無鎖的進行原子操作。原子變數的底層使用了處理器提供的原子指令，但是不同的CPU架構可能提供的原子指令不一樣，也有可能需要某種形式的內部鎖,所

【Java】模擬Sping，實現其IOC和AOP核心（一）

在這裡我要實現的是Spring的IOC和AOP的核心，而且有關IOC的實現，註解+XML能混合使用！ 參考資料： IOC：控制反轉（Inversion of Control，縮寫為IoC），是面向物件程式設計中的一種設計原則，可以用來減低計算機程式碼之間的耦合度。其中最常見的方式叫做依賴注入（D

【java】——單例模式學習理解

    單例模式，總而言之還是多種多樣的，理解不同的單例模式，對於開發過程中更是極為方便，以下彙總幾種單例的使用，積累備用。     一、只適合單執行緒環境 package test; /** * @author xiao

生產者/消費者模式實現

　　wait/notify最經典的案例就是"生產者/消費者"模式。但是此模式有一些需要注意的地方。   1. 一個簡單的生產者消費者 　　一個執行緒向集合中新增元素，兩個集合從集合中刪除元素，與之前等待/通知部落格的最後一個案例類似。 package cn.qlq.thread.sev

【Java】基於jsoup爬蟲實現（從智聯獲取工作資訊）

這幾天在學習Java解析xml，突然想到Dom能不能解析html，結果試了半天行不通，然後就去查了一些資料，發現很多人都在用Jsoup解析html檔案，然後研究了一下，寫了一個簡單的例項，感覺還有很多地方需要潤色，在這裡分享一下我的例項，歡迎交流指教！後續想通過Java把資料匯入到Excel或者

【Java】模擬Sping，實現其IOC和AOP核心（二）

接著上一篇，在上一篇完成了有關IOC的註解實現，這一篇用XML的方式實現IOC，並且完成AOP。 簡易的IOC框圖 註解的方式實現了左邊的分支，那麼就剩下右邊的XML分支： XmlContext：這個類是也是AbstractApplicationContext的子類，和AnnotationContext

【JAVA】Srping和JDBC實現資料庫操作

前言 建立資料庫 首先建立我們的資料庫（這裡我使用的是Mysql），為了演示方便，我這裡簡單的建立一個spring資料庫，然後資料庫有一個user使用者表： 建立一個名為spring的資料庫。 建立一個名為user的資料表，表包括id、email、name

【JAVA】Spring和JdbcTemplate實現資料庫操作

前言 看完【JAVA】Srping和傳統JDBC實現資料庫操作之後，是否覺得傳統的JDBC太繁瑣了，就算是隻寫一個簡單的資料庫插入功能都要寫好多與業務無關的程式碼，那麼使用spring封裝的JdbcTemplate就很有必要了，當然JdbcTemplate也是

【c++】用工廠模式實現計算器功能(附工廠模式程式碼)

工廠模式 編譯環境：Linux vim DynBase.h #ifndef _DYN_BASE_H_ #define _DYN_BASE_H_ #include <map> #inclu

【java】foreach是如何實現的？

1.正文 因為想要了解編譯器是如何實現foreach功能的，就先寫一個foreach迴圈，看看位元組碼長啥樣。 public class ForEach { List<String> list; public void display1(){ f

【Java】SpringMVC整合poi實現excel的匯入匯出

2.特點：結構： HSSF － 提供讀寫Microsoft Excel格式檔案的功能。 XSSF － 提供讀寫Microsoft Excel OOXML格式檔案的功能。 HWPF － 提供讀寫Microsoft Word格式檔案的功能。 HSLF － 提供讀寫Microsof