第八章：多线程

2021年3月20日

12:08

创建线程有4种方式，API里面的两种+JDK5.0新增的两种

解决线程安全有3种方法

 

虚拟机栈和程序计数器是一个线程一份，各线程是独立的

方法区和堆是一个进程一份，各线程共享

即：

每个线程，拥有自己独立的：栈、程序计数器

多个线程，共享同一个进程中的结构：方法区、堆

 

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

 

并行与并发

> 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

> 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

 

* 多线程的创建，方式一：继承于Thread类

* 1. 创建一个继承于Thread类的子类

* 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中

* 3. 创建Thread类的子类的对象

* 4. 通过此对象调用start()：①启动当前线程 ②调用当前线程的run()

*      注意一：我们不能通过直接调用run()的方式启动线程

*      注意二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行，会报IllegalThreadStateException

*      //t1.start();

*      //此时我们需要重新创建一个线程的对象

*      MyThread t2 = new MyThread();

*      t2.start();

*

* Thread.currentThread().getName()获取当前线程的名字

 

 

* 测试Thread中的常用方法：

* 1. start(): 启动当前线程；调用当前线程的run()

* 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

* 3. currentThread(): 静态方法，返回执行当前代码的线程

* 4. getName(): 获取当前线程的名字

* 5. setName(): 设置当前线程的名字 （还可以通过添加String name构造器的方法设置名字）

*      public ThreadMethod(String name){

*         super(name);

*     }

* 6. yield(): 释放当前cpu的执行权（但是有可能释放后cpu还会再分给此线程，所以不是说释放后cpu就一定会去运行其他线程）（后续补充：该方法不会释放锁）

* 7. join(): 在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。抛异常：InterruptedException

* 8. stop(): 已过时。当执行此方法时，强制结束当前线程

* 9. sleep(long millitime): 让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。抛异常：InterruptedException。静态方法，直接用Thread.sleep(millitime)即可。

* 10. isAlive(): 判断当前线程是否存活

 

* 线程的优先级：

* 1.

* MAX_PRIORITY: 10

* MIN_PRIORITY: 1

* NORM_PRIORITY: 5 -->默认优先级

* 2.如何获取和设置当前线程的优先级

*  getPriority(): 获取线程的优先级

*  setPriority(int newPriority): 设置线程的优先级

*

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

 

* 创建多线程的方式二：实现Runnable接口

* 1. 创建一个实现了Runnable接口的类

* 2. 实现类去实现Runnable中的抽象方法：run()

* 3. 创建实现类的对象

* 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

* 5. 通过Thread类的对象调用start()：① 启动线程 ② 调用当前线程的run()-->调用了Runnable类型的target的run()

*      多个线程同时运行的话，创建Thread类的多个对象就可以，它们可以共用Runnable实现类的对象

 

* 比较创建线程的两种方式：

* 开发中：优先选择：实现Runnable接口的方式

* 原因：1. 实现的方式没有类的单继承性的局限性

*      2. 实现的方式更适合来处理多个线程有共享数据的情况（使用的是同一个Runnable实现类的同一个对象的数据）

*      

* 联系：public class Thread implements Runnable

* 相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

                 目前两种方式，要想启动线程，都是调用的Thread类中的start()

 

线程的分类：守护线程和用户线程

 

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

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TERMINATED

宋老师总结的5种状态（跟上面不是对应的）：

 

就绪是start()后cpu没有在运行该线程的状态，运行是start()后cpu在运行该线程的状态。这两个状态会交替

 

阻塞一定不是线程的最终状态，线程的最终状态只能是死亡

 

线程的生命周期

 

* 例子：创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式

*

* 1.问题：卖票过程中，出现了重票（100、100、100）、错票（0、-1） --> 出现了线程的安全问题

* 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票

* 3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

* 4.在Java中，我们通过同步机制，来解决线程的安全问题

*

* 方式一：同步代码块

*

* synchronized(同步监视器){

*      //需要被同步的代码

*

* }

* 说明：1.操作共享数据的代码，即为需要被同步的代码 -->不能包含代码多了，也不能包含代码少了

*                  不能包含代码多了的理解：比如把循环也包住了，那么第一个运行的线程会先锁，然后开始循环，把所有票卖完结束循环后取消锁。第二个运行的线程运行时就没票了

*      2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据

*      3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

*          要求：多个线程必须要共用同一把锁。

*

*      补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

*      synchronized(this){ } //谁调用的run()，this就是谁。在这里是Window1类的对象window调用的，且window唯一

*              在继承Thread类创建多线程的方式中，慎用this充当同步监视器（调用run()的三个对象不相同），考虑使用当前类充当同步监视器

*       synchronized(Aaa.class){ } //类也是一个对象，Aaa是继承Thread的类，三个线程都是Aaa类的对象。类是唯一的。）

*  两个注意点：①共享数据（哪些是共享数据，哪些是操作共享数据的代码）②同步监视器

*

* 方式二：同步方法

*

* 5.同步的方式，解决了线程的安全问题。 ---好处

*   操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

 

* 关于同步方法的总结：

* 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式地声明

* 2. 非静态的同步方法，同步监视器是：this

*     静态的同步方法，同步监视器是：当前类本身

 

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

算法优化：不把return操作看做是对共享数据的操作

 

* 1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了程序的死锁

* 2.说明：

* ①出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

* ②我们使用同步时，要避免出现死锁

解决方法：

    专门的算法、原则

    尽量减少同步资源的定义

    尽量避免嵌套同步

 

正常的，一个方法a中调用同步的方法b的话，会先执行完同步的方法b，才会继续往下执行a。如果同步的方法b阻塞了，那么a后面的代码也无法执行。

但是一个方法a中调用start()方法，不管start()执行后，run()有没有阻塞，有没有运行完，都会继续往下执行a方法中start()后面的代码

 

Lock锁

> 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

> java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

> ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

* 解决线程安全问题的方式三：Lock锁 --- JDK5.0新增

 

各个线程需要保证用的是同一个lock锁，所以继承Thread的多线程实现同步的时候，要把lock设置为static的

 

* 1.面试题：synchronized与Lock的异同？

• 相同：二者都可以解决线程安全问题
• 不同：synchronized机制在执行完相应的同步代码以后，自动地释放同步监视器

*                      Lock需要手动地启动同步（lock()），同时结束同步也需要手动地实现（unlock()）

synchronized 与 Lock 的对比

1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放

2. Lock只有代码块锁，synchronized有代码块锁和方法锁

3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

* 优先使用顺序：

* Lock → 同步代码块（已经进入了方法体，分配了相应资源） → 同步方法（在方法体之外）

*

* 3.面试题：如何解决线程安全问题？有几种方式

* ①同步代码块 ②同步方法 ③Lock锁

 

* 线程通信的例子：使用两个线程打印1-100。线程1，线程2交替打印

* 思路：每一个线程打印完，wait()，然后进入同步之后先唤醒另一个线程，因为是在同步中，所以另一个线程被唤醒后是阻塞状态。

*

* 涉及到的三个方法：

* wait(): 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

* notify(): 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个

* notifyAll(): 一旦执行此方法，就会唤醒所有被wait的线程

*

* 说明：

* 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。

* 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常

* 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中

*

*  面试题：sleep()和wait()的异同

*  1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

*  2.不同点：①两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()

*              ②调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中

*              ③关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

 

不同的代码块a和b，a代码锁定了同一个同步监视器X，其他线程也没法操作b代码

 

* 生产者消费者例题分析：

* 1.是否是多线程问题？是，生产者线程，消费者线程

* 2.是否有共享数据？是，店员、产品

* 3.如何解决线程的安全问题？同步机制，有三种方法

* 4.是否涉及线程的通信？是，唤醒和等待

 

* 创建线程的方式三：实现Callable接口 --- JDK5.0新增

//1.创建一个实现Callable的实现类

//2.实现call()方法，将此线程需要执行的操作声明在call()中

//3.创建Callable接口实现类的对象

//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象

//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()

//6.获取Callable中call()方法的返回值

            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值

 

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

* 1.call()可以有返回值

* 2.call()可以抛出异常，被外面的操作捕获，获取异常的信息

* 3.Callable是支持泛型的

注意：Thread t1 = new Thread(futureTask); 这里是将FutureTask的对象作为参数传递到Thread类的构造器中，而不是将Callable的对象传入。

FutureTask实现了Runnable和Future接口，所以可以作为Thread构造器的参数。

Thread构造器的参数需要的是实现Runnable的对象，单纯的实现Callable的对象不可以作为Thread构造器的参数

 

* 创建线程的方式四：使用线程池

//1. 提供指定线程数量的线程池

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

//3. 关闭连接池

*

* 好处：

* 1.提高响应速度（减少了创建新线程的时间）

* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

* 3.便于线程管理

*      corePoolSize：核心池的大小

*      maximumPoolSize：最大线程数

*      keepAliveTime：线程没有任务时最多保持多长时间后会终止

 

* 面试题：创建多线程有几种方式？四种

* ①继承Thread ②实现Runnable ③实现Callable ④线程池

 

结尾