线程池的使用_while(true)使用綫程池-CSDN博客

本文链接：https://blog.csdn.net/m0_45102548/article/details/103688280

线程池

线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

线程池的使用

ThreadPoolExecutor创建线程池，参数很多，由于可以显示指定队列的大小，所以可以合理避免OOM

(1)corePoolSize：保持在池中的线程数量，如果没有设置

(2)allowCoreThreadTimeout参数，即使这些线程空闲也将一直保持在池中

(3)maximumPoolSize：线程池中的最大线程数量

(4)keepAliveTime：当线程池中空闲线程数量超过corePoolSize时，多余的线程会超过这个保活时间会被销毁；

(5)unit：keepAliveTime的单位

(6)workQueue：任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；

(7)threadFactory：线程工厂，用于创建线程，一般用默认即可；

(8)handler：拒绝策略；当任务太多来不及处理时，如何拒绝任务，有4个策略：
ThreadPoolExecutor.AbortPolicy()：抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy：直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务
ThreadPoolExecutor.DiscardOldestPolicy()：丢弃最老的任务
ThreadPoolExecutor.DiscardPolicy：丢弃当前任务
示例代码：

private ThreadPoolExecutor threadpool;
    public ThreadPool(){
        threadpool=new ThreadPoolExecutor(2, 5,
                20, TimeUnit.SECONDS, new ArrayBlockingQueue(10), new ThreadPoolExecutor.DiscardOldestPolicy());
    }
    public void submit(final int flag){
        threadpool.execute(new Runnable(){
            public void run(){
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(flag + "   aaaaa");
            }
        });
    }
    public void shutdown() {
        threadpool.shutdown();
}
    public static void main(String[] args) {
        ThreadPool t = new ThreadPool();
        for (int i = 0; i < 10; i++) {
            System.out.println("time:" + i);
            t.submit(i);
        }
         System.out.println("----------------------------");
    }
    }

运行结果：

Java通过Executors提供四种线程池：
（1）newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

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

public class ThreadPool {
 public static void main(String[] args) {
        //线程数
        int num = 10;
        //CountDownLatch是一个同步辅助类也可以使用AtomicInteger替代
        CountDownLatch doneSignal = new CountDownLatch(num);
        ExecutorService pool = Executors.newCachedThreadPool();
        for(int i=0;i<num;i++)
            //在未来某个时间执行给定的命令
            pool.execute(new WorkerRunnable(doneSignal, i));
        try {
            doneSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //子线程执行完毕，可以开始后续任务处理了
        System.out.println("所有任务执行完毕");
    }
}
class WorkerRunnable implements Runnable {
    private final CountDownLatch doneSignal;
    private final int i;
    WorkerRunnable(CountDownLatch doneSignal, int i) {
        this.doneSignal = doneSignal;
        this.i = i;
    }
    public void run() {
        //子线程的任务
        try{
            doWork(i);
        }catch (Exception e) {
            e.printStackTrace();
        }
        //任务执行完毕递减锁存器的计数
        doneSignal.countDown();
    }
    void doWork(int i) {
        System.out.println("这是第"+(i+1)+"个任务");
    }
}

运行结果：

（2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

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

public class ThreadPool {
    public static void main(String[] args) {
        线程数
        int num = 5;
        //CountDownLatch是一个同步辅助类也可以使用AtomicInteger替代
        CountDownLatch doneSignal = new CountDownLatch(num);
        ExecutorService pool = Executors.newFixedThreadPool(num);
        for(int i=0;i<num;i++)
            //在未来某个时间执行给定的命令
            pool.execute(new WorkerRunnable(doneSignal, i));
        try {
            doneSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //关闭线程池
            pool.shutdown();
        }
        //子线程执行完毕，可以开始后续任务处理了
        System.out.println("所有任务执行完毕");

    }
}
class WorkerRunnable implements Runnable {
    private final CountDownLatch doneSignal;
    private final int i;
    WorkerRunnable(CountDownLatch doneSignal, int i) {
        this.doneSignal = doneSignal;
        this.i = i;
    }
    public void run() {
        //子线程执行任务
        try {
            doWork(i);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //任务执行完毕递减锁存器的计数
        doneSignal.countDown();
    }
     void doWork(int i) {
        System.out.println("这是第" + (i + 1) + "个任务");
    }
}

运行结果：

（3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

定时：表示延迟3秒执行

public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool =   Executors.newScheduledThreadPool(5);
         scheduledThreadPool.schedule(new Runnable() {
                public void run() {
                    System.out.println("delay 3 seconds");
                }
            }, 3, TimeUnit.SECONDS);
        }

定时及周期性：表示延迟1秒后每3秒执行一次

public static void main(String[] args) {
       ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
         scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
          public void run() {
                System.out.println("delay 1 seconds, and excute every 3 seconds");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }

（4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

 ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
           final int index = i;
           singleThreadExecutor.execute(new Runnable() {
             public void run() {
                  try {
                    System.out.println(index);
                    Thread.sleep(2000); 
                  } catch (InterruptedException e) {
                   e.printStackTrace();
                  }
                }
            });
        }
    }

注意事项

Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2）CachedThreadPool 和 ScheduledThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。