线程池学习笔记

队列阻塞

我们知道栈是先进后出、后进先出的，而队列不同，队列是先进先出、后进后出的。
那么什么是队列阻塞？

对于容量无限的队列：
对容量无限的队列，就不会有阻塞的问题，如果出队时队列里已无数据，则null出队。
有限容量的队列：
在队列容量已满的情况下插入：

插入方法	阻塞时结果
add	抛出异常
offer	返回false，默认等待时间为0
put	一直阻塞
offer（e，time，unit）	超时退出

offer不带参数时和add一样，都不会等待，立刻执行立刻出结果，只是返回不同。

---

移除方法	阻塞时结果
remove	抛出异常
poll	null出队
take	一直阻塞
poll（time，unit）	超时退出

无限长队列程序示例：

public class test01 {
    public static void main(String[] args) {
        //  无边界队列，没有长度限制
        ConcurrentLinkedDeque linkedDeque = new ConcurrentLinkedDeque();
        //  入队
        linkedDeque.add("JAVA");
        linkedDeque.add("C");
        linkedDeque.add("python");
        //出队
        System.out.println(linkedDeque.poll());
        System.out.println(linkedDeque.size());
        //查看，不出队
        System.out.println(linkedDeque.peek());
        System.out.println(linkedDeque.size());
        System.out.println(linkedDeque.poll());
        System.out.println(linkedDeque.poll());
        //出队null
        System.out.println(linkedDeque.poll());
    }
}

result：

JAVA
2
C
2
C
python
null

阻塞队列程序示例：
test02.java

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class test02 implements Runnable {
    static LinkedBlockingQueue<Object> Queue = new LinkedBlockingQueue<Object>(3);
    //类自带三个数据
    test02() {
        Queue.add("原装1");
        Queue.add("原装2");
        Queue.add("原装3");
    }
    //每2秒写一个数据
    void testWrite() {
        int num = 1;
        while (true) {
            String str = "times: " + num++;
            try {
                //每一秒写一次
                TimeUnit.SECONDS.sleep(2);
                Queue.put(str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        this.testWrite();
    }
}

testRead.java

import java.util.concurrent.TimeUnit;

public class testRead {
    public static void main(String[] args) {
        test02 t = new test02();
        Thread thread =new Thread(t);
        thread.start();

        while (true){
            try {
                //每两秒读一次
                TimeUnit.SECONDS.sleep(3);
                System.out.println(test02.Queue.take());
            } catch (InterruptedException e) {
            }
        }
    }
}

线程池使用的就是阻塞队列

---

线程池实现

---

重要实现类：ThreadPoolExecutor

他有五个参数，第一个是最小线程数，也就是线程池常驻的线程数，第二个是线程最大数，第三第四是销毁新线程需要的等待时间和时间单位，第五个是一个阻塞队列实例，用于保存将要执行的任务。
线程池的操作步骤时，如果有任务添加，则先查看是否有常驻的线程空闲，如果有，交给常驻内存，如果没有，则查看阻塞队列是否还有容量，如果有容量，将任务添加进阻塞队列，如果没有，则查看线程数是否得到最大线程数，如果没有，创建线程，如果达到了，抛出异常。
也就是说，正在执行或等待执行的任务总数应该不超过最大线程数+阻塞队列容量。

代码：

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class testpool {
    public static void main(String[] args) {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(1, 2, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3));
        //核心线程执行
        poolExecutor.execute(new duty());
        //以下三条将顺序放进阻塞队列
        poolExecutor.execute(new duty());
        poolExecutor.execute(new duty());
        poolExecutor.execute(new duty());
        //以下任务将使线程池开辟新线程
        poolExecutor.execute(new duty());
        //以下任务将导致报错
        poolExecutor.execute(new duty());
        poolExecutor.shutdown();
    }
}

class duty implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

---

无限线程数无限长对列线程池：Executors.newCachedThreadPool()

这个静态方法返回一个ExecutorService接口的实现类。
它内部也是由ThreadPoolExecutor实现的，只不过不用默认设置成每次添加新线程且最大线程数
为2147483647，且阻塞对列无限长。

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

注意导入依赖时应导入

//正确导入
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//不正确导入
import java.util.concurrent.Executor;

代码测试：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class testPool2 {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();

        for (int i = 0; i < 1000; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        es.shutdown();
    }
}

---

固定线程数无限长对列线程池：Executors.newFixedThreadPool()

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

---

单线程数无限长对列线程池：Executors.newSingleThreadExecutor()

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class testPool5 {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 1000; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {

                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        es.shutdown();
    }
}

---

固定线程数延时执行：Executors.newFixedThreadPool()

public class testPool4 {
    public static void main(String[] args) {
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 100; i++) {
            ses.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            },5, TimeUnit.SECONDS);
        }
        ses.shutdown();
    }
}