java技术深入（一）——java多线程（七）——阻塞队列，生产者-消费者模式

1、阻塞队列（BlockingQueue）适合用来实现生产者-消费者模式。生产者线程会将向阻塞队列中填充数据，消费者会从阻塞队列中取出数据并用于运算。阻塞队列会自动地进行平衡负载，如果生产的速度快于消费的速度，当队列被填满之后，生产者线程会被阻塞。反之，消费者进程会阻塞。

2、BlockingQueue的方法

注意：

a、由于poll和peek函数返回空值来指示失败，所以向阻塞队列中插入null是非法的。

b、offer和pool还有带有超时功能的重载

3、阻塞队列的变体

a、LinkedBlockingQueue：默认长度没有限制，但是也可以指定最大容量

b、LinkedBlockingDeque：LinkedBlockingQueue的双端队列版本。

c、ArrayBlockingQueue：在构造时需要指定容量，提供可选项来指定是否需要公平性，如设置了需要公平性，那么等待了时间最长的线程将会得到最先处理。

d、PriorityBlockingQueue：是一个带优先级的队列，不遵守先入先出规则。队列容量没有上限。如果队列是空的，取元素的操作会阻塞。

下面是阻塞队列的实例：

/BlockQueueTest/src/MyRunner_C.java文件：

import java.util.concurrent.ArrayBlockingQueue;
public class MyRunner_C implements Runnable
{
    private ArrayBlockingQueue que;
    public MyRunner_C(ArrayBlockingQueue _que)
    {
        que = _que;
    }
    @Override
    public void run()
    {
        try
        {
            Thread.sleep(3000);
            Integer i = (Integer) que.take();
            System.out.println(i + "已经被消费了！");
        } catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
}

/BlockQueueTest/src/MyRunner_P.java文件：

import java.util.concurrent.ArrayBlockingQueue;
public class MyRunner_P implements Runnable
{
    private static Integer     count = 0;
    private ArrayBlockingQueue que;
    public MyRunner_P(ArrayBlockingQueue _que)
    {
        que = _que;
    }
    @Override
    public void run()
    {
        try
        {
            Thread.sleep(5000);
            que.put(count);
            System.out.println(count + "已经产生了！");
        } catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
        count++;
    }
}

/BlockQueueTest/src/Test.java文件：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test
{
    public static void main(String[] args)
    {
        ArrayBlockingQueue que = new ArrayBlockingQueue<Integer>(10);
        ExecutorService pool_P = Executors.newFixedThreadPool(10);
        ExecutorService pool_C = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++)
        {
            pool_P.submit(new MyRunner_P(que));
            pool_P.submit(new MyRunner_C(que));
        }
    }
}

效果：

同样的事情用同步锁来做：

/BlockQueueTest/src/MyRunner_CC.java文件：

public class MyRunner_CC implements Runnable
{
    private TaskCount count;
    public MyRunner_CC(TaskCount _count)
    {
        count = _count;
    }
    @Override
    public void run()
    {
        int v = count.changeValue(-1);
        if (v == -1)
        {
            System.out.println("消费失败");
        } else
        {
            System.out.println(v + "已经被消费！");
        }
    }
}

/BlockQueueTest/src/MyRunner_PP.java文件：

public class MyRunner_PP implements Runnable
{
    private TaskCount count;
    public MyRunner_PP(TaskCount _count)
    {
        count = _count;
    }
    @Override
    public void run()
    {
        int v = count.changeValue(1);
        if (v == -1)
        {
            System.out.println("生产失败");
        } else
        {
            System.out.println(v + "已经被生产！");
        }
    }
}

/BlockQueueTest/src/TaskCount.java文件：

public class TaskCount
{
    private Integer count_C = 0;
    private Integer count_P = 0;
    public int changeValue(int type)
    {
        // 对于同一TaskCount对象而言，在同一时间内只允许一个线程执行这段代码，后来的线程将被阻塞直到前面的线程执行完毕。
        // 对于不同TaskCount对象而言，这段代码可以被不同线程同时执行
        // 对于同一TaskCount对象的其他代码段而言，可以允许多个线程同时执行
        synchronized (this)
        {
            if (type == 1)
            {
                try
                {
                    Thread.sleep(5000);
                    count_P++;
                    return count_P;
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            } else if (type == -1)
            {
                if (count_P - count_C > 0)
                {
                    try
                    {
                        Thread.sleep(5000);
                        count_C++;
                        return count_C;
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                } else
                    return -1;
            }
            return -1;
        }
    }
}

/BlockQueueTest/src/Test.java文件：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test
{
    public static void main(String[] args)
    {
        // 同样的事情也可以用同步锁来完成
        TaskCount count = new TaskCount();
        ExecutorService pool_PP = Executors.newFixedThreadPool(10);
        ExecutorService pool_CC = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++)
        {
            pool_PP.submit(new MyRunner_PP(count));
            pool_CC.submit(new MyRunner_CC(count));
        }
    }
}

效果：