JUC之线程、线程池

一、start与run方法

start方法开启一个新线程，异步执行。

run方法同步执行，不会产生新的线程。

start方法只能执行一次，run方法可以执行多次。

二、一些方法

sleep() 线程睡眠

两种方式调用：

Thread.sleep(1000);

TimeUnit.SECONDS.sleep(1);

线程打断

interrupt()这种方式打断，线程会抛出InterruptedException异常。比如在线程睡眠的时候，调用interrupt()，线程抛出异常。抛出InterruptedException异常的时候会清除中断标记。

interrupt()方法仅仅是将线程的中断状态设置为true,并不会停止线程。

thread.interrupt();

还有两个方法

isInterrupted()判断当前线程是否被打断，不会清除打断标记。

interrupted();判断当前线程是否被打断，清除打断标记，静态方法。清除打断标记就是恢复线程的 中断状态。也就是说，在调用Thread.interrupted()方法之后，如果中断了此线程，则不会抛出中断异常，但是如果第二次调用Thread.interrupted()方法的话直接返回false,除非有第二次中断触发。

boolean isInterrupted = thread.isInterrupted();

boolean interrupted = Thread.interrupted();

yield()线程让步

只是让出CPU资源，停止执行当前线程的动作，当前线程的状态回到可运行状态。但是当前线程做出让步以后，下一个CPU资源会在哪个线程的身上，取决去调度器，调度器会在同等优先级的线程之间选择一个分配资源。

设置/获取优先级

优先级设置越大，获得CPU资源的可能性就越高。默认优先级使5，最小1，最大10。

thread.setPriority(10);

int priority = thread.getPriority();

join()等待线程结束

join()

join(long time)

上述两个方法都是等待线程结束，即在执行的地方先等待子线程运行结束再往下继续运行主线程。带参数的是最大等待时间，时间一到则不再等待子线程，主线程继续往下运行。一些场景就是主线程运行依赖于子线程的运行结果。

isAlive()

当前线程是否存活

守护线程

线程分为守护线程和用户线程。默认为用户线程。

setDaemon(boolean on)设置当前线程为守护线程

isDaemon()判断当前线程是否为守护线程。

线程的几种状态和转换

创建线程的三种方式

1、继承Thread类

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

public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("my thread");
        }
}

这种方式是继承的方式，因为java是单继承，所以一般用的不多。

2、实现Runnable,重写run()方法

Thread t1 = new Thread(new RunnableThread());
t1.start();

public static class RunnableThread implements Runnable {
        @Override
        public void run() {
            System.out.println("runnable thread ... ");
        }
    }

这种实现接口的方式推荐使用

3、实现callable，重写call()方法

实现callable的方式，重写的call方法有返回值，这点和Runnable的接口有所不同，并且是交给FutureTask管理，通过future.get()可以获得call()方法的返回值。

注意的是，调用future.get()方法的时候，线程会等待call()方法执行完成，拿到返回值以后才会继续往下执行。

FutureTask futureTask = new FutureTask(new CallableThread());
futureTask.run();
String res = (String) futureTask.get();


public static class CallableThread implements Callable<String> {
        @Override
        public String call() throws Exception {
            System.out.println("callable thread ... ");
            TimeUnit.SECONDS.sleep(5);
            return "callable";
        }
    }

如果不需要返回值的话，用的最常见的就是第二种实现Runnable的方式，并且用lambda的方式，比如：

new Thread(()->{
            System.out.println("thread start ...");
        }).start();

线程池

集中管理线程，节省资源，线程复用，减少开销，便于维护。

Executors提供了固定的几种线程池的创建方式。

1、Executors.newFixedThreadPool(5);创建固定大小的线程池，参数是线程数量

2、Executors.newSingleThreadExecutor();创建只有一个线程数量的线程池
3、Executors.newCachedThreadPool();创建可以扩容的线程池，会一直增加线程数量，不建议使用。

上述3中线程池执行方法：

executorService.execute(()->{});传入Runnable对象

4、Executors.newScheduledThreadPool(5);创建有定时任务的线程池

这种线程池执行的方式scheduledExecutorService.schedule(()->{},5,TimeUnit.SECONDS);

第一个参数是Runnable对象，第二个参数是延迟时间，第三个参数是时间单位。

关闭线程池

shutdown()，等待所有的任务执行完毕关闭线程池。

shutdownNow()，等待正在执行的任务执行完毕后关闭线程池。

awaitTermination(10, TimeUnit.SECONDS)，等待所有任务执行完毕，或者超时以后线程池关闭

isTerminated()线程池是否关闭

线程池的execute和submit方法区别

1、参数不同

execute()方法接收的是Runnable参数

submit接收的是Runnable或者Callable参数

2、返回值不同

execute()方法没有返回值

submit方法有返回值，返回的是Future类型，通过future.get()获得具体的结果。

注意：如果execute传入的是FutureTask类型的话，其实也是可以接收返回结果的。只不过submit替我们封装了FutureTask。

ExecutorService executorService = Executors.newFixedThreadPool(5);
Future<String> future = executorService.submit(() -> {
      return "123";
 });
 String s = future.get();
 System.out.println("s " + s);



 FutureTask<String> futureTask = new FutureTask(() -> {
      return "hello";
 });
 executorService.execute(futureTask);
 System.out.println("futuretask " + futureTask.get());

3、异常捕捉

execute()执行的子线程中的异常，只能子线程进行处理，主线程无法处理，即无法进行 程序的统一异常处理。

submit()中子线程的异常可以在主线程中进行统一异常处理，因为子线程出现异常的时候，并不会立即报错，在进行future.get()进行获取结果的时候才抛出异常，所以主线程可以进行统一异常处理。

自定义线程池

参数：

corePoolSize：核心线程数

maximumPoolSize：最大线程数

keepAliveTime：非核心线程空闲状态存活时间

unit：存活时间单位

workQueue：工作/阻塞队列，

线程先加入到核心线程，核心线程数量达到以后，就会加入到阻塞队列，当阻塞队列满了以后加入非核心线程。

threadFactory：线程工厂

handler：拒绝策略

当线程已经超过了最大线程数加上阻塞队列的数量，就会触发拒绝策略

有四种拒绝策略：

AbortPolicy：拒绝新任务并抛出异常

DiscardPolicy：丢弃任务，不会抛异常

DiscardOldestPolicy：丢弃老的未处理的任务，新的任务加入队列

CallerRunsPolicy：自己处理新的任务，处理的逻辑在传入的Runnable方法中实现。

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(2),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        try {
            for (int i = 0; i < 50; i++) {
                Task task = new Task(i);
                threadPoolExecutor.submit(task);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPoolExecutor.shutdown();
        }

public static class Task implements Runnable {
        int i;

        public Task(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread: "+Thread.currentThread().getName()+" ... ...");
        }
    }