Java线程的三种创建方式 线程池相关

1、直接继承Thread类 重写 run方法

/**
  缺点也很明显 使用继承 牺牲了可拓展性 没有返回值
*/
class MyThread extends Thread{

    @Override
    public void run (){
        for (int i = 0; i < 15 ; i++) {
            System.out.println("子线程执行了："+i);
        }
    }
}

main方法中调用：

	Thread t = new Thread(m2);
	t.start();

2、实现Runnable接口 重写 run方法

/**
  因为java是 单继承，多实现 所以
  相比前者优化了可拓展性  但 还是没有返回值
  而且调用起来相比来说比之前麻烦一点
*/
class MyThread implements Runnable{

    @Override
    public void run (){
        for (int i = 0; i < 15 ; i++) {
            System.out.println( "子线程执行了："+i);
        }
    }
}

main方法中调用：

   //相比之前多了一层包装
	MyThread m = new Mythread();
	new Thread(m1).start();

3、实现Callable接口 重写 call方法

/**
  可以接收返回值了
*/
class MyCallable implements Callable<Integer> {

    int num;
    public MyCallable(int num) {
        this.num = num;
    }
   
    @Override
    public Integer call() throws Exception {
        int sum = 1;
        for (int i = 1; i < this.num; i++) {
            sum*=i;
        }
        return sum;
    }
}

main方法中调用：

	/**
  		FutureTest事实上再底层中也实现了Runnable接口，
  		所以也可以被Thread接收，而自定义的类没有实现Runnable，
  		这样包装三层的话 也比较合理 但是确实有点麻烦
  		最终的返回值通过 FutureTask 的get方法获取 
  		注意：线程未结束之前是不会调用get方法的 可以放心使用
	*/
  Callable<Integer> myCallable = new MyCallable(5);//实现方法

  FutureTask<Integer> ft = new FutureTask<>(myCallable);
    
  new Thread(ft).start();

  System.out.println("最终"+ft.get());

最后一点：

4、获取当前线程 Thread.currentThread()

   Thread now = Thread.currentThread();

5、线程池七大参数

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

1.corePoolSize：核心池的大小；创建了线程池之后，默认情况下，线程池中没有线程，而是等待任务来了之后，创建线程执行任务，当线程的个数达到核心池大小后，后来的任务就会放在缓存队列中。

2.maximumPoolSize：线程池最大线程数，线程池所能容纳的线程。

3.keepAliveTime：多余的线程没有任务执行之后，线程在线程池中最多待多久的时间才销毁，直到只剩下corePoolSize个线程为止。

4.TimeUnit：参数keepAliveTime的时间单位，一共7种取值

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

5.workQueue：一种阻塞队列，用来存储等待线程执行的任务。

6.threadFactory：用来创建线程的工厂

7.RejectedExecutionHandler：表示当线程池满以后，拒绝任务时采取的策略，一共四种策略，如下

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 

7.线程池创建例子：

        ExecutorService pool = new ThreadPoolExecutor(3,5,6,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable runnable = new MyRunnable();//自定义线程对象实现Runnable方法
        pool.execute(runnable);