线程池的介绍及其管理

线程池底层使用阻塞队列BlockingQueue

并发队列
非阻塞队列 ConcurrentLinkedQueue
(poll peek)
阻塞队列 BlockingQueue
(ArrayBlockingQueue offer)

阻塞队列与非阻塞队列

阻塞队列常用于生产者和消费者的场景
生产者–>队列–>消费者
被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作
2. 当队列空了的时候进行出队列操作

入列时，当队列满时：
非阻塞队列，丢失队列信息；
阻塞队列，进行等待；
出列时，当队列为空：
非阻塞队列，返回为null
阻塞队列，进行等待

public static void main(String[] args) throws InterruptedException {
//有界队列  容量为3
  ArrayBlockingQueue<String> abQueue = new ArrayBlockingQueue<String>(3);
  //往队列里加入数量
  System.out.println("开始队列");
  abQueue.offer("student1");
  abQueue.offer("student2");
  abQueue.offer("student3");
  abQueue.offer("student4",3,TimeUnit.SECONDS);
  System.out.println("结束队列");


//获取数据
  System.out.println("开始获取数据");
  System.out.println("队列内数量的量"+abQueue.size());
  System.out.println("获取的数据为:"+abQueue.poll());
  System.out.println("获取的数据为:"+abQueue.poll());
  System.out.println("获取的数据为:"+abQueue.poll());
  System.out.println("获取的数据为:"+abQueue.poll());
  System.out.println("结束数据");

阻塞队列之线程

public class ArrayBlockQueueThread {
 //有界队列  容量3
 public static ArrayBlockingQueue  abQueue= new ArrayBlockingQueue<String>(3);
public static void main(String[] args) {
Thread t1 = new Thread(()->{
try {
    System.out.println("开始队列");
    abQueue.offer("student1");
    abQueue.offer("student2",3,TimeUnit.SECONDS);
    abQueue.offer("student3",3,TimeUnit.SECONDS);
     //队列已满,等待3秒
    abQueue.offer("student4",3,TimeUnit.SECONDS);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
     }
   System.out.println("结束入队列");
  });
  t1.start();

//获取数据
  Thread t2 = new Thread(()->{
   try {
    Thread.currentThread().sleep(2000L);//2秒
    System.out.println("开始获取数据");
    System.out.println("队列内数量的量:"+abQueue.size());
    System.out.println("获取的数据为:"+abQueue.poll());//取第一条student1
//第4条记录可以入队列了
    Thread.currentThread().sleep(2000L);//2秒
    System.out.println("获取的数据:"+abQueue.poll());
    System.out.println("获取的数据:"+abQueue.poll());
    System.out.println("获取的数据:"+abQueue.poll());
System.out.println("获取的数据为:"+abQueue.poll(3,TimeUnit.SECONDS));//取不到
    System.out.println("结束获取数据");
    } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
});
t2.start();
}
}

  
    
    

非阻塞队列

public class ConcurrentLinkedQueueTest2 {
public static void main(String[] args) {
//无界
   ConcurrentLinkedQueue<String> linkedQueue = new ConcurrentLinkedQueue<String>();
   //入队列3条
   linkedQueue.offer("student1");
   linkedQueue.offer("student2");
   linkedQueue.offer("student3");

System.out.println("当前数据的条数:"+linkedQueue.size());
   //只查看数据 不会删除(不会出队列)
   System.out.println("peek当前数据的内容:"+linkedQueue.peek());
System.out.println("当前数据的条数:"+linkedQueue.size());
   System.out.println("poll 当前数据的内容:"+linkedQueue.poll());
   System.out.println("当前数据的条数:"+linkedQueue.size());
   }
   }

Java中的线程池场景及好处
Java中的线程池场景:
运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序;(举例子：域名扫描管理)
好处:
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

线程池作用
线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。

如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

---

线程池的分类

Executor框架的最顶层实现是ThreadPoolExecutor类
Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已

ThreadPoolExecutor线程池介绍：

1.corePoolSize :线程池核心线程数，默认情况下，核心线程会在线程池中一直存活，即使它们处于闲置状态。
2.maximumPoolSize:线程池所能容纳的最大线程数，当活动线程达到这个数值后，后续的新任务将被阻塞。
3.keepAliveTime
非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收。
4.unit
keepAliveTime 参数的时间单位。
5.workQueue：执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

---

线程池四种创建方式
提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

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

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

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

缓存线程池的处理
public class CachePools {
 public static void main(String[] args) {
  ExecutorService es = Executors.newCachedThreadPool();
    for(int i =0;i<20;i++){
     final int temp=i;//任务的号码
     es.submit(()->{
      System.out.println(Thread.currentThread().getName()+"任务号为:"+temp);
     });
    }
    es.shutdown();
    }
    }

固定数量线程池
public class FixedPools {
     public static void main(String[] args) {
     //固定线程池 ,线程数为4个
      ExecutorService es = Executors.newFixedThreadPool(4);
      for(int i=0;i<10;i++){
       final int temp=i;
       es.submit(new Runnable(){
       @Override
    public void run() {
     System.out.println(Thread.currentThread().getName()+"task no"+temp);
     }
     });
     }
     
es.shutdown();
}
}


日程线程池

public class SchedulePools {
 public static void main(String[] args) {
 ScheduledExecutorService ScheduledEs = Executors.newScheduledThreadPool(3);
  SchedulePools x = new SchedulePools();
     MyRun r = x.new MyRun();
  System.out.println("开始执行:");
  ScheduledEs.scheduleAtFixedRate(r, 2, 2, TimeUnit.SECONDS);
  }

public class MyRun implements Runnable{
@Override
  public void run() {
   System.out.println("正在运行");
   }
   }


 单线程线程池
public class SingleThreadPools {
      public static void main(String[] args) {
      ExecutorService es = Executors.newSingleThreadExecutor(); 
      for(int i=0; i<100;i++){
       final int temp=i;
       es.submit(new Runnable(){
       @Override
    public void run() {
     System.out.println(Thread.currentThread().getName()+"任务号");
     }
     });
     }
}
}