java 多线程

1. 线程状态

   Thread.State.NEW; //新建状态（线程未启动）
   Thread.State.RUNNABLE; //就绪状态（线程可运行）
   Thread.State.BLOCKED; //阻塞状态（被锁拦截）
   Thread.State.WAITING; //等待状态（线程暂停） wait()
   Thread.State.TIMED_WAITING; //计时等待（线程暂停） sleep(xxx) wait(xxx)
   Thread.State.TERMINATED; //终止状态（线程结束）
   

1. 创建线程
   1.1. 继承Thread类重写run()方法

       Thread thread1 = new Thread() {
           @Override
           public void run() {
               System.out.println("thread1...");
           }
       };
       thread1.start();
   

   1.2. 实现Runable接口实现run()方法

       Thread thread2 = new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("thread2...");
           }
       });
       thread2.start();
   

   1.3. 实现Callable接口实现call()方法

       FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
           @Override
           public String call() throws Exception {
               System.out.println("thread3...");
               return "thread3...";
           }
       });
       Thread thread3 = new Thread(futureTask);
       thread3.start();
       futureTask.get(); //thread3...
   

2. 线程常用方法
   - 部分需要配合 synchronized 使用
   2.1. Object
   2.1.1. public final void wait() throws InterruptedException; //线程等待(线程暂停)
      - 当前线程暂停执行并释放锁
      - 必须放在synchronized代码内使用
      - 当前线程暂停执行后，当前线程为WAITING状态
      - 当前线程被唤醒后，当前线程转为RUNNABLE状态
   2.1.2. public final native void wait(long timeout) throws InterruptedException; //线程计时等待(线程计时暂停)
      - 当前线程暂停执行并释放锁
      - 必须放在synchronized代码内使用
      - 当前线程暂停执行后，当前线程为TIMED_WAITING状态
      - 当前线程被唤醒后，当前线程转为RUNNABLE状态
      - 需要指定最大暂停时间，如果到达最大暂停时间，当前线程还没被唤醒，当前线程将自动转入RUNNABLE状态
   2.1.3. public final native void notify(); //单线程唤醒
      - 随机唤醒一个被wait()方法暂停的线程
      - 必须放在synchronized代码内使用
      - 线程被唤醒后，被唤醒的线程转为RUNNABLE状态
   2.1.4. public final native void notifyAll(); //多线程唤醒
      - 唤醒所有被wait()方法暂停的线程
      - 必须放在synchronized代码内使用
      - 线程被唤醒后，被唤醒的线程转为RUNNABLE状态
   2.2. Thread
   2.2.01. public synchronized void start(); //启动线程
       - 线程启动后将执行任务内容(任务内容是run()或call()中的内容)
   2.2.02. public long getId(); //获取线程id
   2.2.03. public final String getName(); //获取线程名称
   2.2.04. public final synchronized void setName(String name); //设置线程名称
   2.2.05. public State getState(); //获取线程状态
       - 线程的6种状态参考当前文章开头
   2.2.06. public final int getPriority(); //获取线程优先级
       - 结果为1到10，数字越大优先级越大同时线程被调度执行的几率就越高，默认为5
   2.2.07. public final void setPriority(int newPriority); //设置线程优先级
       - 入参为1到10，数字越大优先级越大同时线程被调度执行的几率就越高，默认为5(Thread.NORM_PRIORITY)，最小为1(MIN_PRIORITY)，最大为10(MAX_PRIORITY)
   2.2.08. public final native boolean isAlive(); //判断线程给是否存活中
       - 线程start()之前和结束后isAlive()返回false，否则返回true
   2.2.09. public final boolean isDaemon(); //判断是否为守护线程(后台线程)
   2.2.10. public final void setDaemon(boolean on); //设置为守护线程或者设置为用户线程
       - 入参为true表示设置为守护线程(后台线程)
       - 入参为false表示设置为用户线程(普通线程/前台线程)
       - 只能在start()之前使用
       - 不使用setDaemon()默认为用户线程(普通线程/前台线程)
       - 用户线程不受主线程的影响，主线程结束用户线程依然可以运行（主线程属于用户线程）
       - 守护线程受用户线程的影响，当所有用户线程结束后，守护线程也会结束

   2.2.11. public final void join() throws InterruptedException; 等待线程结束
       - 当前线程等待指定线程结束（不是指定线程等待当前线程结束）
       - 当前线程等待指定线程时，当前线程为WAITING状态
   2.2.12. public final synchronized void join(long millis) throws InterruptedException;
   // 计时等待线程结束
       - 当前线程等待指定线程结束（不是指定线程等待当前线程结束）
       - 当前线程等待指定线程时，当前线程为TIMED_WAITING状态
       - 需要指定最大等待时间，如果到达最大时间等待的线程还没有结束则当前线程就不等待了直接转为RUNNABLE状态

   2.2.13. public void interrupt(); //终止标识置为true
   2.2.14. public boolean isInterrupted(); //判断终止表示是否置为true
       - 终止标识已经置为true返回true，否则返回false

   2.2.15. public static native void sleep(long millis) throws InterruptedException
       - 当前线程暂停执行并且当获取到锁时不释放锁、
       - 当前线程暂停执行时，当前线程为TIMED_WAITING状态
       - 可以指定最大暂停时间，如果到达最大时间暂停时间，当前线程还没被唤醒，当前线程将自动转入RUNNABLE状态
   2.2.16. public static native Thread currentThread(); //获取当前线程对象
   2.2.17. public static native void sleep(long millis) throws InterruptedException; //线程计时睡眠
       - 当前线程暂停指定的时长并且当获取到锁时不释放锁
       - 当前线程暂停执行后，当前线程为TIMED_WAITING状态
       - 当前线程被唤醒后，当前线程转为RUNNABLE状态
       - 需要指定最大睡眠时间，如果到达最大睡眠时间，当前线程还没被唤醒，当前线程将自动转入RUNNABLE状态
   2.2.18. public static boolean interrupted(); //终止标识归位
       - 已设置终止标识(置为true)时，将终止标识归位(置为false)并返回true
       - 未设置终止标时或终止标识已经归位，直接返回false
   2.2.19. public static native void yield(); //让出本轮cpu执行权等待下轮竞争
   2.3. ReentrantLock
      - https://blog.csdn.net/JMW1407/article/details/122615690

3. 线程池执行流程
   - 引用：https://www.cnblogs.com/dongye95/p/16352895.html
   

4. 创建线程池
   5.1. 直接new线程池对象

      /**
       * ExecutorService是ThreadPoolExecutor的间接父类
       * 入参解析：
       */
      ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(int corePoolSize,
                                                                     int maximumPoolSize,
                                                                     long keepAliveTime,
                                                                     TimeUnit unit,
                                                                     BlockingQueue<Runnable> workQueue,
                                                                     ThreadFactory threadFactory,
                                                                     RejectedExecutionHandler handler);
   

   5.2. 提交任务
   5.2.1. void execute(Runnable command); //提交无需返回结果的任务
   5.2.2. Future submit(Callable task); //提交需要返回结果的任务
      - 需要调用结果对象的get方法获取任务结果
      - 调用结果对象的get()获取任务结果，没获取到结果会一直阻塞，直到获取到结果
      - 调用结果对象的get(long timeout, TimeUnit unit)获取任务结果，超时时间内没获取到结果会一直阻塞，超时时间到仍没获取到结果抛异常TimeoutException
   5.3. 线程池监控
   5.4. 关闭线程池
      -- 略，一般不用 --