android 消费者和生产者的队列处理模型

package com.android.settings;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class BeidouDetailSettingsActivity extends Activity {

    private static final String TAG = "BeidouDetailSettingsActivity";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>(2);
        // BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
        // 不设置的话，LinkedBlockingQueue默认大小为Integer.MAX_VALUE

        // BlockingQueue<String> queue = new ArrayBlockingQueue<String>(2);

        /**
         * 模拟处理用户的请求
         */
        Consumer consumer = new Consumer(queue);
        Producer producer = new Producer(queue);
        for (int i = 0; i < 5; i++) {
            new Thread(producer, "Producer" + (i + 1)).start();

            new Thread(consumer, "Consumer" + (i + 1)).start();

        }

    }

    /**
     *
     * @author tianxuhong
     *
     *         原来有种需求： 1. 对于用户的请求都依次的排队，请求需要不定时的完成，对于用户相同的请求则舍弃，必须保证这些请求操作依次完成，
     *         如果一次出错则全部放弃后期的操作，对于原来的起一个线程池，如果线程池不空，则操作，线程池是空的则阻塞。后来设计的类似消费者和生产者模型的机制处理。
     *
     */

    public class Producer implements Runnable {
        BlockingQueue<String> queue;

        public Producer(BlockingQueue<String> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                String temp = "A Product, 生产线程："
                        + Thread.currentThread().getName();
                System.out.println("I have made a product:"
                        + Thread.currentThread().getName());
                queue.put(temp);// 如果队列是满的话，会阻塞当前线程
                /**
                 * 对于所有的 用户请求加入队列
                 */

                Log.d(TAG, "Producer=" + temp);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public class Consumer implements Runnable {
        BlockingQueue<String> queue;

        public Consumer(BlockingQueue<String> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                String temp = queue.take();// 如果队列为空，会阻塞当前线程
                System.out.println(temp);
                Log.d(TAG, "Consumer=" + temp);
                ConsumerhandleEnable(temp, queue);
                Log.d(TAG, "Consumer done>>>>>>>>>>>>>>>>>=" + temp);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void ConsumerhandleEnable(String temp, BlockingQueue<String> queue) {
        Log.d(TAG, "Consumer handleEnable>>>>>>>>>>>>>>>>>=" + temp);


        /**
         * send some message
         */
        //  在这里处理用户的请求，然后等待请求的结果，如果有则唤醒线程。
        synchronized (queue) {
            try {
                queue.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        /**
         * check the result
         */

        Log.d(TAG, "Consumer handleEnable>>>>>>>>>>>>>>>>>don...");
    }

    /**
     * 设置某种条件去唤醒消费者，即处理后续队列的请求
     * @param queue
     * @return
     */
    private int notification(BlockingQueue<String> queue) {
        queue.notify();

        return 0;
    }

}