线程创建4种方式（普通 + lambda）

1.继承Thread类

class A extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

       //（调用）
       Thread t1 = new A();
       t1.start();

匿名内部类

//匿名内部类 产生子类对象
new Thread(){
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}.start();

2.实现Runnable接口

class B implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}
      //调用
	  Thread t2 = new Thread(new B());
      t2.start();

new Thread(new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}).start();

匿名内部类

//匿名内部类 产生接口实现类对象
Runnable r =  new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
};
new Thread(r).start();

用lambda表达式

//lambda表达式
new Thread(()->{
    System.out.println(Thread.currentThread().getName());
}).start();

3. 实现Callable接口

• 有返回值，有泛型，可以抛异常
• 要引入未来任务FutureTask把它包装一下，因为只有FutureTask实现了Runable接口,是一个Runable Target

// lambda表达式
  FutureTask<Integer> futureTask = new FutureTask(()->{
            System.out.println(Thread.currentThread().getName());
            return 10086;
        });
        new Thread(futureTask).run();
        System.out.println(futureTask.get());

public class CreateThread {
    public static void main(String[] args) {
         /** 实现Callable接口
         有返回值，有泛型，可以抛异常
         要引入未来任务FutureTask把它包装一下，因为只有FutureTask实现了Runable接口,是          一个Runable Target
         */
        一个Runable Target
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new C());
        Thread t3 = new Thread(futureTask);
        t3.run();
        try {
//          获取返回值
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class C implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
        return 10086;
    }

4. 通过线程池创建线程
// 提前创建好线程放进线程池里里面，
// 避免重复创建销毁线程，降低资源消耗，提高响应速率

1)newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

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

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

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

ExecutorService实现类对象.ThreadPoolExecutor

        /**
         * 通过线程池创建线程
         * 提前创建好线程放进线程池里里面，
         * 避免重复创建销毁线程，降低资源消耗，提高响应速率
         * */
        ExecutorService executorService = Executors.newFixedThreadPool(3);
//实现类对象是class java.util.concurrent.ThreadPoolExecutor
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        });
        executorService.execute(new FutureTask<Integer>(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName());
            }
            return 666;
        }));
        executorService.shutdown();