并发编程学习（一）

并发编程学习（一）

参考博文：http://blog.youkuaiyun.com/defonds/article/details/44021605/

BlockQueue：通常用于a线程产生对象，b线程消费a产生的对象。

模型图如下：

blockqueue的特性：

1、使用方是：a/b线程

2、有阈值

3、使用方a/b线程均会阻塞，a线程阻塞的原因是：插入元素已满。b线程阻塞的原因是队列为空。

blockqueue的API

分别完成对元素的添加、移除、检查

	抛异常	特定值	阻塞	超时
插入	add(o)	offer(o)	put(o)	offer(o, timeout, timeunit)
移除	remove(o)	poll(o)	take(o)	poll(timeout, timeunit)
检查	element(o)	peek(o)

1. 抛异常：如果试图的操作无法立即执行，抛一个异常。

2. 特定值：如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。

3. 阻塞：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。

4. 超时：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。

在插入操作中不会向队列中插入一个null值。

在队列操作中不仅仅可以访问开始和结束的元素，比如执行remove()方法，但是这种操作效率不高。

BlockQueue的实现

BlockQueue是一个接口，其实现类有如下：

1、ArrayBlockQueue

2、DelayQueue

3、LinkedBlockingQueue

4、PriorityBlockingQueue

5、SynchronousQueue

五个实现类。

下面展示其中一个实现类的使用方法：

ArrayBlockQueue：

package test.block.queue;




import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;




/**
 * 创建了两个线程，每个线程具有BlockQueue的一个引用，这样两者就可以互相通信
 * ，consumer线程可以消费producer线程 完成了两个线程之间的数据传递，共享。
 * 这里我们做了一个实验：验证BlockQueue阻塞队列的特征：
 * 将ArrayBlockQueue最大阈值设置为1，我们将consumer线程注释掉，
 * 这样就会发现线程只会完成第一个元素的存放，不会放入第二个元素
 * 
 * @author caiqiang
 * @version 2017年3月25日
 * @see BlockQueueTest
 * @since
 */
public class BlockQueueTest {


    public static void main(String[] args)
        throws InterruptedException {
        // 创建一个BlockQueue，并用ArrayBlockQueue实例化
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);


        Producer producer = new Producer(blockingQueue);
        Consumer consumer = new Consumer(blockingQueue);


        new Thread(producer).start();
        // new Thread(consumer).start();


        Thread.sleep(4000);
    }


}

package test.block.queue;


import java.util.concurrent.BlockingQueue;


public class Consumer implements Runnable {

    protected BlockingQueue<String> blockQueue = null;

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

    @Override
    public void run() {

        try {
            System.out.println("take from ===>" + blockQueue.take());
            Thread.sleep(1000);
            System.out.println("take from ===>" + blockQueue.take());
            Thread.sleep(1000);
            System.out.println("take from ===>" + blockQueue.take());
        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

package test.block.queue;


import java.util.concurrent.BlockingQueue;


public class Producer implements Runnable {

    protected BlockingQueue<String> blockQueue = null;

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

    @Override
    public void run() {

        try {
            blockQueue.put("1");
            // Thread.sleep(1000);
            System.out.println("放入第一个元素");
            blockQueue.put("2");
            // Thread.sleep(1000);
            System.out.println("放入第二个元素");
            blockQueue.put("3");
            // Thread.sleep(1000);

        }
        catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

在上述实验中可以发现生产的线程会因最大线程个数为1，而因为没有消费线程阻塞，没有继续存入值。