java线程和线程池使用

1. 继承Thread

Thread01 thread = new Thread01();
thread.start();

    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+ i );
        }
    }

2. 实现Runnable接口

Runable01 runnable01 = new Runnable01();
Thread thread = new Thread(runnable01);
thread.start();

    public static class Runnable01 implements Runnable{

        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+ i );
        }
    }

3. 实现Callable接口 + FutureTask （可以拿到返回结果，可以处理异常）

FutureTask<Integer> future = new FutureTask<>(new Callable01());
Thread thread = new Thread(future);
thread.start();
//阻塞等待整个线程执行完成，获取返回结果
Integer integer = future.get();

    public static class Callable01 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+ i );
            return i;
        }
    }

4. 线程池[ExecutorService]

• 给线程池直接提交任务
• 我们以后在业务代码里面，以上三种启动线程的方式都不用。

好处

降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
提高响应速度 ：因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无须创建新的线程就能执行
提高线程的可管理性 ：线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

七大参数

1. corePoolSize ：
核心线程数[一直存在，除非设置(allowCoreThreadTimeOut)]，创建好以后就准备的线程数量，就等待来接受异步任务去执行

2. maximumPoolSize ：
最大线程数量；控制资源

3. keepAliveTime ：
存活时间，如果当前线程数量大于核心线程数，只要线程空闲大于指定的时间(keepAliveTime)，就会释放空闲的核心线程外的线程(maximumPoolSize - corePoolSize)。

4. unit ：
时间单位

5. BlockingQueue workQueue
阻塞队列，如果任务很多，线程都在工作，将目前多的任务放在队列里面。只要有线程空闲，就会去队列里面取出新的任务继续执行

6. ThreadFactory
线程创建的工厂

7. RejectedExecutionHandler

如果队列满了，按照我们指定的拒绝策略，拒绝执行任务

AbortPolicy ：抛出运行时异常RejectedExecutionException。这种策略丢弃任务，并抛出异常。（jdk默认策略）

CallerRunsPolicy : 线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

DiscardOldestPolicy（弃老策略）jdk：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序。

DiscardPolicy ：发生拒绝策略时，不触发任何动作

工作顺序

1、线程池创建，准备好core数量的核心线程，准备接受任务

2、新的任务进来，用core准备好的空闲线程执行
        2.1、core满了，就将再进来的任务放入阻塞队列中。空闲的core就会自己去阻塞队列获取任务执行
        2.2、阻塞队列满了，就直接开新线程执行，最大只能开到max指定的数量
        2.3、max满了就用RejectedExecutionHandler拒绝任务

        2.4、max都执行完成，有很多空闲，在指定的时间keepAliveTime以后，释放空闲的线程(max-core)。
new LinkedBlockingDeque<>()：默认是Integer的最大值，可能会导入内存不够

ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
        200,
        10,
        TimeUnit.SECONDS,
        new LinkedBlockingDeque<>(100000),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.AbortPolicy() //丢弃最新的任务策略
);

 常见线程池

newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。core是0，所有都可以回收
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在对队列中等待。固定大小，core=max。都不可回收
newScheduledThreadPool
创建一个定长线程池。支持定势及周期性人去执行。定时任务的线程池
newSingleThreadExecutor
创建一个单线程化的线程池，他只会用唯一的工作线程来执行任务，保证所有任务按顺序执行

Executors.newCachedThreadPool(); //core是0,所有都可回收
Executors.newFixedThreadPool(100); //固定大小，core=max 都不可回收
Executors.newScheduledThreadPool(100); //定时任务的线程池
Executors.newSingleThreadExecutor(); //单线程线程池