多线程笔记

package com.example;



/**
 * 多线程笔记
 * @author: liuyl
 * @date: 11:50 2022/5/13
 */
public class TreadNote {
    /**
     * 一、并发与并行
     *    并发：CPU分时轮询的执行线程。
     *    并行：同一时刻同时执行。
     *
     *
     * 二、java.lang.Thread类
     *  构造方法
     *      public Thread() 分配一个新的线程对象
     *      public Thread(String name) 分配一个指定名称的线程对象
     *      public Thread(Runnable target) 分配一个带有指定目标新的线程对象
     *      public Thread(Runnable target,String name) 分配一个带有指定目标新的线程对象并指定名称
     *  常用方法
     *      public String getName() 获取当前线程名称
     *      public void setName(String name) 设置当前线程名称
     *      public void start() 启动线程
     *      public void run() 此线程要执行的任务在此处定义代码
     *      public static void sleep(long millis) 使当前正在运行的线程以指定的毫秒值暂停  对应线程新状态为：TimedWaiting（计时等待）
     *      public static Thread currentThread()  返回对当前正在执行的线程对象的引用
     *
     *
     * 三、线程使用方式
     *  1. 实现Runnable（无返回值）
     *      new Thread(new Runnable() {
     *           @Override
     *           public void run() {
     *              //定义业务代码
     *           }
     *      }).start();
     *
     *  2. 实现Callable
     *      FutureTask ft = new FutureTask<T>(new Callable<T>(){
     *          @Override
     *          public String call() throws Exception{
     *              //定义业务代码
     *              return null;
     *          }
     *      });
     *      new Thread(ft).start()
     *      //获取返回值
     *      T result = ft.get();
     *
     *  3. 继承Thread
     *      new Thread().start()
     *
     *
     * 四、线程的六种状态
     *  新建（NEW） -- 创建线程对象
     *  可运行（Runnable） -- start方法
     *  Blocked 锁阻塞  -- 无法获得锁对象
     *  Waiting 无限等待 -- wait方法
     *  TimedWaiting 计时等待 -- sleep方法
     *  Terminated 被终止 -- 全部代码执行完毕
     *
     *
     * 五、线程安全：线程安全问题都是由全局变量和静态变量引起的
     * 解决方案：
     *  1. 同步代码块
     *      synchronized(同步锁){  //注：同步锁可以是任务对象
     *          //可能产生线程安全问题的代码
     *      }
     *
     *  2. 同步方法
     *      public synchronized void method(){
     *          //可能产生线程安全问题的代码
     *      }
     *
     *      同步锁？
     *          非static方法，同步锁是this
     *          static方法同步锁一般为当前方法所在类的字节码对象（类名.class）
     *
     *  3. 锁机制（java.util.current.locks.Lock锁）
     *      Lock lock = new ReentrantLock();
     *      public void lock() 加锁
     *      public void unlock() 释放锁
     *
     *
     *
     * 六、线程池（ExecutorService）
     *  获取线程池
     *      方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
     *            ThreadPoolExecutor tpe = public ThreadPoolExecutor(int corePoolSize, -- 指定线程池的线程数量（核心线程）
     *                               int maximumPoolSize, -- 指定线程池可支持的最大线程数
     *                               long keepAliveTime, -- 指定临时线程的最大存活时间
     *                               TimeUnit unit, -- 指定存活时间的单位(秒、分、时、天)
     *                               BlockingQueue<Runnable> workQueue, -- 指定任务队列
     *                               ThreadFactory threadFactory, -- 指定用哪个线程工厂创建线程
     *                               RejectedExecutionHandler handler) -- 指定线程忙，任务满的时候，新任务来了怎么办
     *            新任务拒绝策略：
     *              ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。【是默认的策略】
     *              ThreadPoolExecutor.DiscardPolicy 丢弃任务，但是不抛出异常 这是不推荐的做法
     *              ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中
     *              ThreadPoolExecutor.CallerRunsPolicy 由主线程负责调用任务的run()方法从而绕过线程池直接执行
     *
     *      方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象（Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的）
     *          public static ExecutorService newCachedThreadPool() 线程数量随着任务增加而增加，如果线程任务执行完毕空闲的一段时间则回被回收掉
     *          public static ExecutorService newFixedThreadPool(int nThreads) 创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池回补充一个新线程代替它
     *          public static ExecutorService newSingleThreadExecutor() 创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池回补充一个新线程
     *          public static ScheduledExecutorService newScheduledThreadPool(int corePooleSize) 创建一个线程池，可以实现在给顶的延迟后运行任务，或定期执行任务
     *
     *
     *  ExecutorService的常用方法
     *      void execute(Runnable command) 执行任务/命令，没有返回值，一般用来执行Runnable任务
     *      Future<T> submit(Callable<T> task) 执行任务，返回未来对象获取线程结果，一般拿来执行Callable任务
     *      void shutdown() 等任务执行完毕后关闭线程池
     *      List<Runnable> shutdownNow() 立即关闭，停止正在执行的任务，并返回队列中未执行的任务
     *
     *
     *
     * 七、定时器
     *  实现方式
     *      方式一：Timer
     *          public Timer() 创建Timer定时器对象
     *      方式二：ScheduledExecutorService
     *          public void schedule(TimerTask task, long delay, long period) 开启一个定时器，按照计划处理TimerTask任务
     *
     *  Timer定时器的特点和存在的问题
     *      1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入
     *      2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。
     *
     *  Executors的方法
     *      public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 得到线程池对象
     *  ScheduledExecutorService的方法
     *      public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit) 周期调度方法
     *
     *  ScheduledExecutorService的优点
     *      1、基于线程池，某个任务的执行情况不会影响其他定时任务的执行
     *
     */

}