java 线程

https://www.jianshu.com/p/edd7cb4eafa0
https://blog.csdn.net/vbirdbest/article/details/81282163
觉得上面地址的内容很好，所以看完后，总结一下加强记忆

一、基础知识

程序>进程>线程
单核CPU一次只能执行一个进程，因为切换快，所以认为进程是并行的
多核CPU执行是真正的并行执行，现在基本电脑都是多核，只是核数不同
一个进程可以有多个线程，一个线程对应一个Stack区，一个进程对应一个堆，进程中的线程共享进程的资源

二、创建线程

创建线程的几种方法
1.new Thread
2.实现Runable接口，然后new Thread（Runnable run）
3.实现Callable，然后包装成java.util.concurrent.FutureTask, 再然后包装成Thread
4.通过线程池创建

new Thread

public class Main {
    public static void main(String[] args) {
        new MyThread().start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
    }
}

实现Runable接口

public class Main {
    public static void main(String[] args) {
    	 // 将Runnable实现类作为Thread的构造参数传递到Thread类中，然后启动Thread类
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());
    }
}

实现Callable接口

public class Main {
    public static void main(String[] args) throws Exception {
    	 // 将Callable包装成FutureTask，FutureTask也是一种Runnable
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

        // get方法会阻塞调用的线程
        Integer sum = futureTask.get();
        System.out.println(Thread.currentThread().getName() + Thread.currentThread().getId() + "=" + sum);
    }
}


class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId() + "\t" + new Date() + " \tstarting...");

        int sum = 0;
        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }
        Thread.sleep(5000);

        System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId() + "\t" + new Date() + " \tover...");
        return sum;
    }
}

以上三种总结
new Thread和实现Runable因为继承Thread后，就不能继承了，所以用Runable，可以多实现

Callable和Runnable的区别如下：

Callable定义的方法是call，而Runnable定义的方法是run。
Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。
Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。

Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，RunnableFuture继承Runnable，所以Callable也算是一种Runnable，所以三种实现方式本质上都是Runnable实现

三、线程池

1.特点

（1） 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
（2） 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行；
（3） 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2.种类

newSingleThreadExecutor：一个单线程的线程池，可以用于需要保证顺序执行的场景，并且只有一个线程在执行。
newFixedThreadPool：一个固定大小的线程池，可以用于已知并发压力的情况下，对线程数做限制。
newCachedThreadPool：一个可以无限扩大的线程池，比较适合处理执行时间比较小的任务。
newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。
newWorkStealingPool：一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。（这个不太理解，需要再看看）

3.线程池的创建

两种：

1.工具类

事例

ExecutorService service3 = Executors.newFixedThreadPool(10);

2.自定义线程池

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) ;

参数：
corePoolSize
线程池大小，决定着新提交的任务是新开线程去执行还是放到任务队列中，也是线程池的最最核心的参数。一般线程池开始时是没有线程的，只有当任务来了并且线程数量小于corePoolSize才会创建线程。
maximumPoolSize
最大线程数，线程池能创建的最大线程数量。
keepAliveTime
在线程数量超过corePoolSize后，多余空闲线程的最大存活时间。
unit
时间单位
workQueue
存放来不及处理的任务的队列，是一个BlockingQueue。
threadFactory
生产线程的工厂类，可以定义线程名，优先级等。

ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
              .setNameFormat("demo-pool-%d").build();

handler
拒绝策略，当任务来不及处理的时候，如何处理, 前面有讲解。
1、 AbortPolicy – 当任务添加到线程池中被拒绝时，它将抛出 RejectedExecutionException 异常。
2、 CallerRunsPolicy – 当任务添加到线程池中被拒绝时，会在线程池当前正在运行的Thread线程池中处理被拒绝的任务。
3、 DiscardOldestPolicy – 当任务添加到线程池中被拒绝时，线程池会放弃等待队列中最旧的未处理任务，然后将被拒绝的任务添加到等待队列中。
4、 DiscardPolicy – 当任务添加到线程池中被拒绝时，线程池将丢弃被拒绝 的任务。

其中ThreadFactoryBuilder是通过实现ThreadFactory生成的类

ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("demo-pool-%d").build();
ExecutorService pool = new ThreadPoolExecutor(5, 200,0L, 
TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(1024), 
namedThreadFactory, new ThreadPoolExecutor.CallerRunsPolicy());
for(int i=0;i<1000;i++) {
   pool.execute(() -> {
   //todo 此处写业务
   });
}

那么如何用线程池执行任务呢？

针对Runable和Callable有不同的执行方法
通过java.util.concurrent.ExecutorService接口对象来执行任务，该对象有两个方法可以执行任务execute和submit。execute这种方式提交没有返回值，也就不能判断是否执行成功。submit这种方式它会返回一个Future对象，通过future的get方法来获取返回值，get方法会阻塞住直到任务完成。

execute与submit区别：

接收的参数不一样
submit有返回值，而execute没有
submit方便Exception处理
execute是Executor接口中唯一定义的方法；submit是ExecutorService（该接口继承Executor）中定义的方法

executor.execute(runable)
executor.submit(callable)

对于callable任务的返回值Future介绍

主要是get（）方法，用于获取返回值，并且但未执行完时，当前代码处会阻塞，当执行完后才会返回并执行后续代码。