JavaSE 笔记【五】多线程

视频链接：Java零基础教程

程序、进程、线程

• 程序：一段静态的代码

• 进程：正在运行的一个程序，进程是动态的，进程作为资源分配的单位

• 线程：线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）

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

并发与并行

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事

何时需要多线程

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

创建多线程

方式一： 继承Thread类

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() 方法 --> 将此线程执行的操作声明在run() 方法中
3. 创建Thread类的子类的对象
4. 通过此对象调用start() 方法 --> ①启动当前线程 ②调用当前线程的run() 方法

Thread常用方法

1. start() ：启动当前线程，调用当前线程的run() 方法。不可以二次调用同一对象的start() 方法，会报IllegalThreadStateException。我们需要重新创建一个线程的对象再次执行
2. run() ：通常需要重写Thead类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread() ：静态方法，返回执行当前代码的线程
4. getName() ：获取当前线程的名字
5. setName() ：设置当前线程的名字
6. yield() ：静态方法，释放当前cpu的执行权，this.yield() 等同于 Thread.currentThread().yield()
7. join() ：在线程a中调用线程b的join() 方法，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
8. stop() ：已过时，当执行此方法时，强制结束当前进程
9. sleep(Long millitime) ：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态
10. isAlive() ：判断当前线程是否存活

线程的优先级

线程的优先级等级

• MAX_PRIORITY：10
• MIN_PRIORITY：1
• NORM_PRIORITY：5 默认优先级

Thread常用优先级方法

• getPriority() ：返回线程的优先级
• setPriority(int newPriority) ：改变线程的优先级

说明：

1. 线程创建时继承父类的优先级
2. 高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完之后，低优先级的线程才执行

方式二： 实现Runnable接口

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

比较创建线程的两种方式

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

1. 实现的方式没有类的单继承的局限性
2. 实现的方式更适合来处理多个线程有共享数据的情况
   联系：
3. Thread类也实现了Runnable接口
4. 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

线程的生命周期

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

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

Thread.State

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

线程的安全问题

多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据

如何解决：
当一个线程a在操作的时候，其他线程不能参与进来。直到线程a操作完后，其他线程才可以开始操作。这种情况即使线程a出现了阻塞，也不能被改变
在java中，通过同步机制来解决线程的安全问题

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

方式一：同步代码块

// 方式一：实现Runnable接口创建多线程的方式中，可以使用this指针把当前对象作为监视器
//方式二：new一个对象作为监视器，继承Thread类创建多线程的方式中，慎用this充当同步监视器，也可以把当前类.class作为监视器（类也是一种对象, 类只会加载一次）
synchronized(同步监视器) {
	// 需要被同步的代码
}

说明：

1. 操作共享数据的代码，即为需要被同步的代码。–>不能包含代码多了，也不能包含代码少了
2. 共享数据：多个线程共同操作的变量。比如：买票系统中的票
3. 同步监视器，俗称：锁。任何一个类的对象，都可以称当锁。要求：多个线程必须要共用同一把锁

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的，在方法前加synchronized关键字

实现Runnable接口，同步方法：同步监视器：this
继承Thread类，同步方法：方法必须是静态方法，同步监视器：当前类本身

线程安全的单例模式（Java）

线程的死锁问题
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决办法：
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

方式三：Lock（锁）

从JDK 5.0开始，Java提供了更强大的线程同步机制–通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享数据资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

class LockTest implements Runnable {

  // 1.实例化ReentrantLock
  private ReentrantLock lock = new ReentrantLock();
  
  @Override
  public void run() {
    try { // 放到try代码块中，保证最终finally能够解锁
      lock.lock();
      // 下面写如要同步的代码
    } finally {
      lock.unlock();
    }
  }
}

面试题：synchronized和Lock的异同
异：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。Lock需要手动的启动同步（lock()），同时结束同步也需要手动实现（unlock()）
同：二者都可以解决线程安全问题

线程的通信

sleep()不会释放锁

线程通信涉及的三个方法：
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. 不同点：
   1）两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
   2） 调用的要求不同：sleep() 可以在任何需要的场景下调用。wait() 必须使用在同步代码或同步方法中
   3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep() 不会释放锁，wait()会释放锁

JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比，Callable功能更强大些

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

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. 获取Callable中call方法的返回值

   class NumThread implements Callable<Integer> {
   
     @Override
     public Integer call() throws Exception {
       int sum = 0;
       for (int i = 0; i <= 100; i++) {
         if (i % 2 == 0) {
           System.out.println(i);
           sum += i;
         }
       }
       return sum;
     }
   }
   
   class ThreadNew {
   
     public static void main(String[] args) {
       NumThread numThread = new NumThread();
       FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
       new Thread(futureTask).start();
   
       try {
         // get() 返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
         Integer sum = futureTask.get();
         System.out.println("总和为：" + sum);
       } catch (InterruptedException | ExecutionException e) {
         e.printStackTrace();
       }
     }
   }
   

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

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

新增方式二：使用线程池

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

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

JDK 5.0起提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
• Future submit(Callable task) ：执行任务，有返回值，一般来执行Callable
• void

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

• Executors.newCachedThreadPool() ：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n) ：创建一个可重用固定线程数的线程池
• Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n) ：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

实现步骤：

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

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

   class NumberThread implements Runnable {
     @Override
     public void run() {
       for (int i = 0; i <= 100; i++) {
         if (i % 2 == 0) {
           System.out.println(Thread.currentThread().getName() + ": " + i);
         }
       }
     }
   }
   
   class NumberThread1 implements Runnable {
     @Override
     public void run() {
       for (int i = 0; i <= 100; i++) {
         if (i % 2 != 0) {
           System.out.println(Thread.currentThread().getName() + ": " + i);
         }
       }
     }
   }
   
   public class ThreadPool {
   
     public static void main(String[] args) {
       // 1. 提供指定线程数量的线程池
       ExecutorService service = Executors.newFixedThreadPool(10);
       ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
   
       // 设置线程池的属性
   //    System.out.println(service.getClass());
       service1.setCorePoolSize(15);
   
   
       service.execute(new NumberThread()); // 适用于Runnable
       service.execute(new NumberThread1()); // 适用于Runnable
   //    service.submit(Callable callable); // 适用于Callable
       // 关闭线程池
       service.shutdown();
     }
   }
   

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