9-Java高级：多线程

一、基本概念

1.1 程序、进程、线程

• 程序(program): 为完成特定任务、用某种语言编写的一组指令的集合；即一段静态的代码
• 进程(process): 程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程——有它自身的产生、存在和消亡的过程——声明周期
  • 程序是静态的，进程是动态的；
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域；
• 线程(thread): 进程可进一步细化为线程，是一个程序内部的一条执行路径
  • 若一个进程同一时间并行执行多个线程，就是支撑多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(PC)，线程切换的开销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间——它们从同一堆中分配对象，可以访问相同的变量和对象，使得线程间的通信更简便、高效；但多个线程操作共享的系统资源可能会带来安全的隐患

1.2 单核CPU和多核CPU

• 单核CPU： 在一个时间单元内，只能执行一个线程的任务
• 多核CPU： 在一个时间单元内，可以多线程

注： 一个Java应用程序java.exe，至少有三个线程：main()主线程、gc()垃圾回收线程、异常处理线程；若发生异常，会影响主线程

1.3 并行与并发

• 并行： 多个CPU同时执行多个任务
• 并发： 一个CPU（时间片）同时执行多个任务

1.4 使用多线程的优点

• 提高应用程序的响应——对图形化界面更有意义，可增强用户体验
• 提高计算机系统CPU的利用率
• 改善程序结构——将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

1.5 何时需要多线程

• 程序需要同时执行两个或多个任务
• 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
• 需要一些后台运行的程序时

二、线程的创建与使用

2.1 方式一： 继承于$Thread$类

1. 创建一个继承于$Thread$类的子类
2. 重写$Thread$类的$run()$——此线程要执行的操作
3. 创建该子类的对象
4. 通过此对象调用$start()$——①启动当前线程；②调用当前线程的run()

注1： $Thread$类的有关方法
   1. $voidstart()$ : 启动线程，并执行当前线程的run()方法
   2. $run()$ : 线程在被调度时执行的操作——通常需要重写Thread类中的此方法
   3. $StringgetName()$ : 返回线程的名称
   4. $voidsetName()$ : 设置该线程名称
   5. $staticThreadcurrentThread()$ : 返回当前线程，
   6. $staticnativeyield()$ : 线程让步——暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
   7. $finalvoidjoin()$ : ①在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行以后，线程a才结束阻塞状态；②抛出$InterruptedException$异常——使用$try-catch$
   8. $staticvoidsleep(longmillis)$ : ①令当前活动线程在指定时间段内放弃对CPU的控制，使其他线程有机会被执行，时间到后重新排队【等待CPU分配资源】；②抛出$InterruptedException$异常——使用$try-catch$【父类的sleep没有throws，那么子类重写的方法也要没有】
   9. $stop()$ : 强制结束当前线程生命期（不推荐）
   10. $booleanIsAlive$ ： 判断线程是否还活着

注2： 线程的调度
1.调度策略： ①时间片；②抢占式：高优先级的线程抢占CPU
2.Java的调度方法：
  > 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
  >对高优先级，使用优先调度的抢占式策略
3.线程的优先级：
   > 线程的优先等级：①MAX_PRIORITY:10;②MIN_PRIORITY:1;③NORM_PRIORITY：5——默认的
   > 获取和设置优先级：①$getPriority$: 返回线程优先级；②$setPriority(intnewPriority)$:改变线程的优先级
   > 说明：①线程创建时继承父线程的优先级；②低优先级只是获得被调度的概率低，并非一定是在高优先级线程之后被调用

2.2 方式二： 实现$Runnable$接口

1. 创建一个实现了$Runnable$接口的类
2. 实现类去实现$Runnable$接口中的抽象方法：$run()$
3. 创建实现类的对象
4. 将此对象作为参数传递到$Thread$类的构造器中，创建$Thread$类的对象
5. 通过$Thread$类的对象调用$start()$:①启动线程；②调用当前线程的$run()$—>调用了$Runnable$类型的$target$的$run()$

class Thread implements Runnable{
	...
	private Runnable target;
	...
	public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }
	...
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    ...
  }

2.3 比较创建线程的两种方式

开放中，优先选择 实现$Runnable$接口的方式（差异）
  1. 实现的方式是接口，没有类的单继承性的局限性
  2.实现的方式更适合来处理多个线程有共享数据的情况

二者的联系：
  1. $Thread$类本身也继承了$Runnable$
  2. 两种方式都需要重写$run()$，将线程要执行的逻辑声明在其中

2.4 线程的分类

Java中的线程可以分为两类：守护线程和用户线程

• 两者几乎每个方面都是相同的，唯一的区别是判断JVM何时离开
• 守护线程是用来服务用户线程的，在start()方法前调用【用户线程结束，守护线程也随之结束】
• 若JVM中都是守护线程，当前JVM将推出
• 垃圾回收gc()就是一个典型的守护线程
• 使用$thread.setDaemon(true)$可以把一个用户线程变为一个守护线程

三、线程的生命周期

JDK中用$Thread.State$ 类定义了线程的几种状态

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

线程的声明周期：
  1. 新建： 当一个$Thread$类及其子类的都西昂被声明并创建时，新生的线程对象处于新建状态
  2. 就绪： 处于新建状态的线程被$start()$后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  3. 运行： 当就绪的线程被调度并获得CPU资源时，便进入运行状态，$run()$方法定义了线程的操作和功能
  4. 阻塞： 在某种特殊情况下，被人挂起或执行输入输出操作时，线程会让出CPU并临时中止，进入阻塞状态
  5. 死亡： 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

四、线程的同步

线程的安全问题：
  1. 多个线程执行的不确定性引起执行结果的不稳定
  2.多个线程共享某个数据，会出现操作的不完整性，破坏数据

解决： 当一个线程a在操作某个共享数据的时候，其他线程不能参与进来，直到线程a操作完毕，即使a正在阻塞，其他线程也无法参与进来

Java中，通过同步机制，来解决线程的安全问题

4.1 同步机制

4.1.1 方式一：同步代码块

synchronized(同步监视器){
	//需要被同步的代码
}

注： 1.操作共享数据的代码，即为需要被同步的代码——不能包含代码多了，也不能包含代码少了
     2.同步监视器，俗称“锁”，任何一个类的对象，都可以充当锁——要求多个线程必须要共用同一把锁——谁抢到了锁就可以操作数据，并把“门”关上
     3.在实现$Runnable$接口创建多线程的方式中，可以考虑使用$this$充当同步监视器；而使用继承$Thread$类创建多线程的方式中，要慎用$this$充当同步监视器——不是同一把锁了，可以考虑使用当前类充当同步监视器

4.1.2 方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明为同步的
  1.方法声明中加一个 $synchronized$关键字
  2.需要将同步监视器变为静态方法来保证同步监视器是唯一的，那么此时的同步监视器为当前类

同步的方式，好处是解决了线程的安全问题，但局限是操作同步代码时，只能有一个线程参与，其他线程等待，相当于一个单线程过程，效率低

4.1.3 补充：使用同步机制将单例模式中的懒汉式改写为线程安全的

class Bank{
    private Bank(){}
    //同步方法
    private static Bank instance = null;
//    public static synchronized Bank getInstance(){
//        if(instance ==null){
//            instance = new Bank();
//            return instance;
//        }
//        return instance;
//    }
    //同步代码块
    public static Bank getInstance(){
        //方式一：效率差——需要不停地判断
//        synchronized (Bank.class){
//            if(instance ==null){
//                instance = new Bank();
//                return instance;
//            }
//            return instance;
//        }
        //方式二
        if(instance == null){
            synchronized (Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

4.1.4 JDK5.0新增的同步机制——Lock(锁)

1. 可以通过显示定义同步锁对象——$Lock$对象来实现同步
2. $java.util.concurrent.locks.Lock$接口是控制多个线程对共享资源进行访问的工具：锁提供了对共享资源的独占访问，每次只能有一个线程对$Lock$对象加锁，线程开始访问共享资源之前应获得$Lock$对象
3. $ReentrantLock$类实现了$Lock$，该类拥有与$synchronized$相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是$ReentrantLock$，可以显式枷锁、释放锁

具体使用步骤：
  1. 实例化$ReentrantLock$,其中,构造器参数默认为false，若设置为true,将会按照先进先出策略对依次来的线程加锁
  2.调用加锁方法$lock()$
  3.调用解锁方法$unlock()$
注： 使用$try-fianlly$结构，保证遇到异常就停止同时无论失败还是成功都会解锁：$try$结构中包住操作共享数据的代码，同时第一行调用加锁方法，$finally$结构中调用解锁方法——该结构中的代码一定会被执行

class Window5 implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    // ctrl + p，查看构造器
    // 参数默认为false,设置为 true ,即公平，符合先进先出
    private ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try{
                //2.调用锁定的方法:lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票号为： "+ ticket--);
                }else{
                    break;
                }
            }finally{
                //3.调用解锁的方法:unlock
                lock.unlock();
            }

        }
    }
}

面试题： $synchronized$ 与 $Lock$ 的异同:
相同： 二者都可以解决线程安全问题
区别：
  1. $synchronized$ 是隐式锁，该机制在执行完相应的同步代码以后，会自动释放同步监视器； $Lock$ 是显式锁，需要手动的启动同步，同时需要手动结束同步
  2. $synchronized$有代码块锁和方法锁；$Lock$ 只有代码块锁
  3. 使用$Lock$锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供了更多的子类）

优先使用顺序： $Lock$ - > 同步代码块（已经进入了方法体，分配了相应资源）- > 同步方法（在方法体外）

4.2 线程的死锁问题

死锁： 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源——出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决：
  1. 使用专门的算法、原则
  2. 尽量减少同步资源的定义
  3. 尽量避免嵌套同步

4.3 小结

释放锁的操作：

• 当前线程的同步方法、同步代码块执行结束
• 当前线程在同步代码块、同步方法遇到$break$、$return$终止了该代码块
• 当前线程在同步代码块、同步方法种出现了未处理的$Error$或$Exception$，导致异常结束
• 当前线程在同步代码块、同步方法种执行了线程对象的$wait()$方法，当前线程暂停，并释放锁

不会释放锁的操作：

• 线程执行同步代码块或同步方法时，程序调用了$Thread.sleep()$、$Thread.yield()$方法暂停了当前线程的执行
• 线程执行同步代码块时，其他线程调用了该线程的$suspend()$方法将该线程挂起，该线程不会释放锁（同步监视器）

五、线程的通信

5.1 基本概念

线程通信涉及到三个方法：

• $wait():$ 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
• $notify()：$ 一旦执行此方法，就会唤醒被$wait$的一个线程；如果有多个线程被阻塞，就唤醒优先级最高的那个
• $notifyAll()：$ 一旦执行此方法，就会唤醒所有被阻塞的线程

注：
  1. $wait()$、$notify()$、$notifyAll()$三个方法必须使用在同步代码块或同步方法中
  2. $wait()$、$notify()$、$notifyAll()$三个方法的调用者必须是同步代码块或同步方法中的监视器
  2. $wait()$、$notify()$、$notifyAll()$三个方法是定义在$java.lang.Object$中——那么任何一个类的对象作为监视器都可以调用这些方法【Object类是所有类的父类】

5.2 面试题

1. $sleep()$和$wait()$的异同？
      a） 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
      b）不同点：
        + 两个方法声明的位置不同：$Thread$类中声明$sleep()$，$Object$类中声明$wait()$
        + 调用的范围不同：$sleep()$可以在任何需要的场景下调用，$wait()$必须使用在同步代码块或同步方法中
        + 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，$sleep()$不会释放锁，$wait()$会释放锁

六、JDK5.0新增线程创建方式

6.1 新增方式一： 实现$Callable$接口

• 相比$run()$方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助$FutureTask$类，比如获取返回结果

注： Future接口

• 可以对具体$Runnable$、$Callable$任务的执行结果进行取消、查询是否完成、获取结果等
• $FutureTask$ 是$Future$接口的唯一的实现类
• $FutureTask$同时实现了$Runnable$、$Future$接口，它既可以作为$Runnable$被线程执行，又可以作为$Future$得到$Callable$的返回值

步骤：

1. 创建一个实现$Callable$的实现类
2. 实现$call$方法，将此线程需要执行的操作声明在$call()$中
3. 创建$Callable$接口实现类的对象
4. 将此$Callable$接口实现类对象传递到 $FutureTask$构造器中，创建$FutureTask$的对象
5. 将 $FutureTask$的对象作为参数传递到$Thread$类的构造器中，创建$Thread$的对象，并调用$start()$方法启动贤臣
6. 通过$FutureTask$对象调用$FutureTask$类的$get()$可以获取$Callable$中$call()$的返回值——$get()$返回值即为$FutureTask$构造器参数$Callable$实现类重写的$call()$返回值

如何理解实现$Callable$接口的方式创建多线程比实现$Runnable$接口创建多线程方式强大？

• $call()$可以有返回值
• $call()$可以抛出异常，被外面的操作捕获，获取异常的信息
• $Callable$支持泛型

6.2 新增方式二： 使用线程池

背景： 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路： 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中——可以避免频繁创建销毁、实现重复利用

好处：

• 提高响应速度——减少了创建新线程的时间）
• 降低资源消耗——重复利用线程池中的线程，不需要每次都创建
• 便于线程管理：
  • $corePoolSize$ : 核心池的大小
  • $maximumPoolSize$ : 最大线程数
  • $keepAliveTime$ ： 线程没有任务时最多保持多长事件后终止
  • …

步骤：
   1.提供指定线程数量的线程池
     > 简单一点可以使用 $ExecutorService$ 接口进行创建

ExecutorService service = Executors.newFixedThreadPool(10);

     > 复杂一点可以使用$ExecutorService$接口的实现类$ThreadPoolExecutor$的构造器进行创建——提供了四种构造器


   2. 执行指定的线程的操作，需要提供实现$Runnable$接口或$Callable$接口的实现类的对象

service.execute(new xxxx);//适合适用于
service.submit(new xxxx);//适合适用于Callable

   3. 关闭连接池

service.shutdown();