多线程笔记（学习尚硅谷java基础教程）

一、基本概念：
    程序：
        是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
    进程：
        是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
            程序是静态的，进程是动态的
            进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
    线程：
        进程可进一步细化为线程，是一个程序内部的一条执行路径。
        若一个进程同一时间并行执行多个线程，就是支持多线程的
        线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
        一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
二、线程的创建和使用
    1、jdk5之前
         继承Thread类的方式
            1) 定义子类继承Thread类。
            2) 子类中重写Thread类中的run方法。  -----将此线程执行的操作声明在run()中
            3) 创建Thread子类对象，即创建了线程对象。
            4) 调用线程对象start方法：启动线程，调用run方法。
             注意点：
                1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。 可用Thread.currentThread().getName()方法验证
                2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
                3. 想要启动多线程，必须调用start方法。
                4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。
             Thread类的有关方法
                void start(): 启动线程，并执行对象的run()方法
                run(): 线程在被调度时执行的操作
                String getName(): 返回线程的名称
                void setName(String name):设置该线程名称
                static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
                static void yield()：线程让步
                    暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
                    若队列中没有同优先级的线程，忽略此方法
                join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
                    低优先级的线程也可以获得执行
                static void sleep(long millis)：(指定时间:毫秒)
                    令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
                    抛出InterruptedException异常
                stop(): 强制线程生命期结束，不推荐使用
                boolean isAlive()：返回boolean，判断线程是否还活着
                线程的优先级：
                    1.MAX_PRIORITY：10
                      MIN _PRIORITY：1
                      NORM_PRIORITY：5  -->默认优先级
                    2.如何获取和设置当前线程的优先级：
                      getPriority():获取线程的优先级
                      setPriority(int p):设置线程的优先级

                     说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

         实现Runnable接口的方式
            1) 定义子类，实现Runnable接口。
            2) 子类中重写Runnable接口中的run方法。
            3) 通过Thread类含参构造器创建线程对象。
            4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
            5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
            public class Thread extends Object implements Runnable

        对比：
             区别
                 继承Thread：线程代码存放Thread子类run方法中。
                 实现Runnable：线程代码存在接口的子类的run方法。
             实现方式的好处
                 避免了单继承的局限性
                 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
    2、jdk5新增
        新增方式一：实现Callable接口
             与使用Runnable相比， Callable功能更强大些
                 相比run()方法，可以有返回值
                 方法可以抛出异常
                 支持泛型的返回值
                 需要借助FutureTask类，比如获取返回结果
             Future接口
                 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
                 FutrueTask是Futrue接口的唯一的实现类
                 FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
             使用Callable接口实现多线程的步骤：
                 创建一个实现Callable的实现类
                 实现call方法，将此线程需要执行的操作声明在call()中
                 创建Callable接口实现类的对象
                 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
                 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
                 获取Callable中call方法的返回值 （使用FutureTask类的get()方法）
                    Thread类来启动，FutureTask类来获取，两个互不干涉，不可替代。

        新增方式二：使用线程池
             背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
             思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
             好处：
                 提高响应速度（减少了创建新线程的时间）
                 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
                 便于线程管理
                     corePoolSize：核心池的大小
                     maximumPoolSize：最大线程数
                     keepAliveTime：线程没有任务时最多保持多长时间后会终止
             线程池相关API
                 JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
                 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
                     void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
                     <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
                     void shutdown() ：关闭连接池
                 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
                     Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
                     Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
                     Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
                     Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
             使用基本步骤
                1. 提供指定线程数量的线程池
                2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
                3. 关闭连接池
三、线程的生命周期
    JDK中用Thread.State类定义了线程的几种状态要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，
在它的一个完整的生命周期中通常要经历如下的五种状态：
        新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
        就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
        运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
        阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
        死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
    线程状态转换
        新建到就绪：start()
        就绪到运行：得到cpu资源
        运行到就绪：失去cpu资源 | yield()
        运行到死亡：stop( ) | Error或Exception | run( )执行完成
        运行到阻塞：sleep()       | 等待同步锁 | wait()   | join()      | suspend( )
        阻塞到就绪：sleep( )时间到 | 获得同步锁 | notify() | notifyAll() | resume( )

四、线程的同步  --解决安全问题
     问题的提出
        多个线程执行的不确定性引起执行结果的不稳定
        多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
        2. 问题的原因：
            当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
        3. 解决办法：
            对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
      同步机制中的锁（详细说明）
         同步锁机制： 在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资
        源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解
        锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
         synchronized的锁是什么？
             任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
             同步方法的锁：静态方法（类名.class）、非静态方法（this）
             同步代码块：自己指定，很多时候也是指定为this或类名.class
         注意：
             必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
             一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
      同步的范围
        1、如何找问题，即代码是否存在线程安全？（非常重要）
            （1）明确哪些代码是多线程运行的代码
            （2）明确多个线程是否有共享数据
            （3）明确多线程运行代码中是否有多条语句操作共享数据
        2、如何解决呢？（非常重要）
            对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中
        3、切记：
             范围太小：没锁住所有有安全问题的代码
             范围太大：没发挥多线程的功能。

      Synchronized的使用方法：（同步机制）
        1. 同步代码块：
            synchronized (对象){
            // 需要被同步的代码；
            }

            说明：
            1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
            2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
            3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。
            4.在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
            5.在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。(synchronized (Thread.class) {)

        2. synchronized还可以放在方法声明中，表示整个方法为同步方法。
            public synchronized void show (String name){
            ….

            关于同步方法的总结：
                1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
                2. 非静态的同步方法，同步监视器是：this
                   静态的同步方法，同步监视器是：当前类本身
      Lock(锁)
       从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
       java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
       ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
        案例：
            class A{
            private final ReentrantLock lock = new ReenTrantLock();
            public void m(){
            lock.lock();
            try{
            //保证线程安全的代码;
            }
            finally{
            lock.unlock();
            }
            }
            }

        synchronized 与 Lock 的对比：
            1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
            2. Lock只有代码块锁，synchronized有代码块锁和方法锁
            3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
            优先使用顺序：Lock  同步代码块（已经进入了方法体，分配了相应资源）  同步方法（在方法体之外）

      释放锁的操作
         当前线程的同步方法、同步代码块执行结束。
         当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
         当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
         当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
      不会释放锁的操作
        线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
        线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
            应尽量避免使用suspend()和resume()来控制线程
     死锁
        死锁
            不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
            出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
        解决方法
            专门的算法、原则
            尽量减少同步资源的定义
            尽量避免嵌套同步

五、线程的通信
    一、方法：
        wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器（sleep是不会释放同步监视器的）。
            在当前线程中调用方法： 对象名.wait()
            使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify(或notifyAll) 为止。
            调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
            调用此方法后，当前线程将释放对象监控权 ，然后进入等待
            在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
        notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
        notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
            notify()/notifyAll()共同点：
                在当前线程中调用方法： 对象名.notify()
                功能：唤醒等待该对象监控权的一个/所有线程。
                调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

            说明：
                1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
                2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
                3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
                    因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。
    面试题：sleep() 和 wait()的异同？
        1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
        2.不同点:1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
                2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
                3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

视频教程来源：https://www.bilibili.com/video/BV1Kb411W75N