线程池：队列

参考：

 

JCU中SynchronousQueue、LinkedBlockingQueue、ArrayBlockingQueue简析

 

45张图庖丁解牛18种Queue，你知道几种？

 

BlockingQueue是一个接口

常见的实现有LinkedBlockingQueue和ArrayBlockingQueue

用linkedBlockingQueue的好处是大小没有限制，优点是队列容量非常大，执行execute时不会抛出异常。

而线程池中的线程数永远不会大于corePoolSize值，因为其他多余的线程被放在队列中了，keepAliveTime也就没有意义了

常见3种队列结合max值的因果效果

使用ThreadPoolExecutor线程池中常见的三种队列 ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue

ArrayBlockingQueue，LinkedBlockingQueue 这两种队列可以指定队列存储元素的个数

linkedBlockingDeque

package threads.excutors.test8;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
        LinkedBlockingDeque linkedBlockingDeque=new LinkedBlockingDeque<Runnable>(2);
        System.out.println(linkedBlockingDeque.size());
        ThreadPoolExecutor executor=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,
                linkedBlockingDeque);
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        System.out.println(executor.getPoolSize()+" "+linkedBlockingDeque.size());
        //正在执行的线程数是3  队列中存放的元素个数2
    }
}

package threads.excutors.test8;
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("begin "+System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println("end "+System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

package threads.excutors.test8;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test1 {
    public static void main(String[] args) {
        LinkedBlockingDeque linkedBlockingDeque=new LinkedBlockingDeque<Runnable>(2);
        System.out.println(linkedBlockingDeque.size());
        ThreadPoolExecutor executor=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,
                linkedBlockingDeque);
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        System.out.println(executor.getPoolSize()+" "+linkedBlockingDeque.size());
        //队列的容量不够，有一个任务出现了异常
        //放入了队列2个任务，执行了三个任务，有一个任务被拒绝了
        //因为跑异常了，所以主线程上最后的那个没打印出来
    }
}

package threads.excutors.test8;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test1 {
    public static void main(String[] args) {
        //max值被忽略
        LinkedBlockingDeque linkedBlockingDeque=new LinkedBlockingDeque<Runnable>();
        System.out.println(linkedBlockingDeque.size());
        ThreadPoolExecutor executor=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,
                linkedBlockingDeque);
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        executor.execute(new MyRunnable());
        System.out.println(executor.getPoolSize()+" "+linkedBlockingDeque.size());
        //队列的最大容量为Integer.Max
        //最开始 放入了队列3个任务，执行了2个任务
        //最终 是把所有的任务都执行的
    }
}

ArrayBlockingQueue

package threads.excutors.test8;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test2 {
    public static void main(String[] args) {
        ArrayBlockingQueue queue=new ArrayBlockingQueue(2);//最大容量max值被参考
        System.out.println(queue.size());
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,queue);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        System.out.println(pool.getPoolSize()+" "+queue.size());
        //一开始 总共5个任务，执行了3个任务，放入队列2个任务
    }
}

package threads.excutors.test8;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test2 {
    public static void main(String[] args) {
        ArrayBlockingQueue queue=new ArrayBlockingQueue(2);//最大容量max值被参考
        System.out.println(queue.size());
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,queue);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        System.out.println(pool.getPoolSize()+" "+queue.size());
        //一开始 总共6个任务
        //执行了3个任务，放入队列了2个任务，还有一个任务，因为队列容量不够了，所以抛异常了
    }
}

这个ArrayBlockingQueue在构造时必须的设置最大的大小

SynchronousQueue

package threads.excutors.test8;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test2 {
    public static void main(String[] args) {
        SynchronousQueue queue=new SynchronousQueue<Runnable>();
        System.out.println(queue.size());
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,queue);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        System.out.println(pool.getPoolSize()+" "+queue.size());
        //总共有3个任务，直接放在线程池中执行了
    }
}

package threads.excutors.test8;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test2 {
    public static void main(String[] args) {
        SynchronousQueue queue=new SynchronousQueue<Runnable>();
        System.out.println(queue.size());
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,3,5, TimeUnit.SECONDS,queue);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        System.out.println(pool.getPoolSize()+" "+queue.size());
        //总共有4个任务，直接放在线程池中执行了3个任务，另外一个就被拒绝了
    }
}