Java线程池实现原理之自定义线程池（一）

1.队列的概念

谈到多线程先讲下队列的概念，之后的多线程学习会用到此类知识。

队列分为：阻塞式队列(有界)、非阻塞式队列(无界),遵循着先进先出、后进后出的原则。
阻塞队列与非阻塞队列区别：
  1.非阻塞式队列超出队列总数会丢失。
  2.阻塞式队列超出总数会进入等待（等待时间=设置超时时间）。
  3.获取队列方面：非阻塞式队列，如果为空返回null。阻塞式队列，如果为空也会进入等待。

非阻塞式队列ConcurrentLinkedDeque

 //非阻塞式队列 无界(可以声明无限个队列)
     public static void test1(){

         ConcurrentLinkedDeque<Object> objects = new ConcurrentLinkedDeque<>();
         objects.offer("java001");
         objects.offer("java002");

         System.out.println("队列总数："+objects.size());

         //建议：获取队列之后删除
         System.out.println("获取队列但不删除："+objects.peek());
         System.out.println("获取队列但不删除,队列总数："+objects.size());
         System.out.println("获取队列删除："+objects.poll());

         //非阻塞式队列，如果为空返回null
         System.out.println(objects.poll());
         System.out.println(objects.poll());
         System.out.println(objects.poll());
         System.out.println("获取队列删除,队列总数："+objects.size());
     }

阻塞式队列ArrayBlockingQueue

 //阻塞式队列
     public static void test2() throws InterruptedException {

         long startTime=System.currentTimeMillis();
         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
         arrayBlockingQueue.offer("A001",3, TimeUnit.SECONDS);
         arrayBlockingQueue.offer("A002",3, TimeUnit.SECONDS);

         //阻塞式队列超出总数等待（等待时间=设置超时时间）
         arrayBlockingQueue.offer("A003",3, TimeUnit.SECONDS);
         arrayBlockingQueue.offer("A004",1, TimeUnit.SECONDS);
         arrayBlockingQueue.offer("A005",1, TimeUnit.SECONDS);

         System.out.println("队列总数："+arrayBlockingQueue.size());
         System.out.println(arrayBlockingQueue.poll());
         System.out.println(arrayBlockingQueue.poll());
         System.out.println(arrayBlockingQueue.poll());
         //阻塞式队列，如果为空也会等待。
         System.out.println(arrayBlockingQueue.poll(1, TimeUnit.SECONDS));
         System.out.println("队列剩余总数："+arrayBlockingQueue.size());

         System.out.println("耗时："+ (System.currentTimeMillis() - startTime)/1000 +"秒");

     }

2.线程池

线程池好处：
      1.降低资源 => 重复利用机制 (降低创建线程和销毁线程)
      2.提高响应效率 => 当任务到达时,任务可以不需要等待去创建线程就可以执行
      3.方便管理 => 无限创建线程消耗资源、降低系统稳定性。使用线程池可以统一分配、调优、监控。
线程与任务的区别：
      可以把线程理解成一个工作人员。而任务就是这个工作人员干的活。比如，餐厅的工作人员在为顾客传菜，传菜就是个任务。

      Java中线程就是Thread类或其子类的一个实例。
      也就是说你不必关注线程对象是用哪种方法创建的。在此基础上，线程所执行的代码，即run方法中的代码所实现的处理逻辑，
      比如读取数据库中的一条记录，就是一个任务。因此，所谓任务是一个相对的概念。一个任务可以是读取数据库中的一条记录，
      也可以是FTP传输一批文件，FTP传输一个文件……

 //创建线程四种方式：
     //1.可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     //2.定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     //3.可定时线程池，支持定时及周期性任务执行。
     //4.单例线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
     public static void test1() {

         //1.可缓存、定时、定长、单例
         ExecutorService executorService = Executors.newCachedThreadPool();
         for (int i = 0; i <10 ; i++) {
             final int i1 = i;
             executorService.execute(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(Thread.currentThread().getName()+",i:"+ i1);
                 }
             });
         }

     }

     public static void test2() {

         //2.可定长线程,核心线程5个,最多创建5个线程 (只会创建5个线程,其他线程共享这5个线程)
         ExecutorService executorService = Executors.newFixedThreadPool(5);
         for (int i = 0; i <10 ; i++) {
             final int i1 = i;
             executorService.execute(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(Thread.currentThread().getName()+",i:"+ i1);
                 }
             });
         }
     }

     public static void test3() {

         long l = System.currentTimeMillis();
         //3.可定时线程 =>核心线程数3 (延迟三秒执行)
         ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
         for (int i = 0; i <10 ; i++) {

             final int i1 = i;
             scheduledExecutorService.schedule(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(Thread.currentThread().getName()+",i:"+ i1);
                     System.out.println("耗时："+ (System.currentTimeMillis() -l)/1000 +"秒" );
                 }
             },3, TimeUnit.SECONDS);
         }

     }

     public static void test4() {

         //4.单例线程 =>核心线程数1 最大线程数1
         ExecutorService executorService = Executors.newSingleThreadExecutor();
         for (int i = 0; i <10 ; i++) {
             final int i1 = i;
             executorService.execute(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(Thread.currentThread().getName()+",i:"+ i1);
                 }
             });
         }
     }