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);
                }
            });
        }
    }