13、多线程

1. 线程简介

程序、进程和线程

1. 程序

   程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

2. 进程

   线程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。

3. 线程

   • 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。

   • 线程是CPU调度和执行的的单位。

• 线程就是独立的执行路径

• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，GC 线程等；

• main() 称之为主线程，为系统的入口，用于执行整个程序；

• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的；

• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；

• 线程会带来额外的开销，如 CPU 调度时间，并发控制开销；

• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

主线程和子线程并行交替执行

2. 线程创建

2.1 继承 Thread 类 ‼️

创建步骤：

1. 自定义线程类继承 Thread 类
2. 重写 run() 方法，编写线程执行体
3. 创建子类对象，子类对象调用 start() 方法启动线程

代码示例：

public class Demo extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("run------------------------------------");
        }
    }

    public static void main(String[] args) {
        new Demo().start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main++++++++");
        }
    }

}

线程开启后不一定立即执行，由 CPU 安排调度。

2.2 实现 Runnable 接口 ‼️

创建步骤：

1. 自定义线程类实现 Runnable 接口
2. 重写 run() 方法，编写线程执行体
3. 创建线程类 Thread 对象，传入自定义线程类对象，Thread 类对象调用 start() 方法启动线程

代码示例：

public class Demo implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("run-------------------------------------------------");
        }
    }


    public static void main(String[] args) {
        new Thread(new Demo()).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main+++++++++++++++++++");
        }
    }

}

推荐使用 Runnable 实现多线程，因为 Java 单继承的局限性

2.3 实现 Callable 接口

创建步骤：

1. 实现 Callable 接口（需要返回值类型）
2. 重写 call() 方法（需要抛出异常）
3. 创建目标对象
4. 创建执行服务：ExecutorService serv = Executors.newFixedThreadPool(1);
5. 提交执行：Future<Boolean> res = serv.submit(t);
6. 获取结果：boolean r = result.get();
7. 关闭服务：serv.shutdownNow();

2.4 静态代理

真实对象和代理对象都需要实现同一接口。

代码示例：

public class Demo {

    public static void main(String[] args) {
        TicketService tsi = new TicketServiceImpl();
        TicketProxy tp = new TicketProxy(tsi);

        tp.buyTicket();
    }

}

interface TicketService {

    void buyTicket();

}

class TicketServiceImpl implements TicketService {

    @Override
    public void buyTicket() {
        System.out.println("正在购票");
    }

}

class TicketProxy implements TicketService {

    private TicketService target;

    public TicketProxy(TicketService target) {
        this.target = target;
    }

    @Override
    public void buyTicket() {
        System.out.println("前往购票");
        target.buyTicket();
        System.out.println("购票完成");
    }

}

2.5 Lambda 表达式

• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
• Lambda 避免内部类定义过多。
• Lambda 表达式属于函数式编程。

语法

(parameters) -> expression
或
(parameters) ->{ statements; }

parameters 是参数列表，expression 或 { statements; } 是 Lambda 表达式的主体。

• 如果只有一个参数，可以省略括号；如果没有参数，也需要空括号。

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

• 对于函数式接口，可以通过 lambda 表达式来创建该接口的对象

3. 线程状态

---

线程可以处于以下状态之一（Thread.State）：

• NEW

  尚未启动的线程处于此状态

• RUNNABLE

  在 JVM 中执行的线程处于此状态

• BLOCKED

  被阻塞、等待监视器锁定的线程处于此状态

• WAITING

  正在等待另一个线程执行特定动作的线程处于此状态

• TIMED_WAITING

  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

• TERMINATED

  已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态。

• 这些状态是不反映任何操作系统线程状态的虚拟机状态

线程方法：

• public void start()

  使该线程开始执行；

  JVM 调用该线程的 run() 方法

• public void run()

  如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run() 方法；

  否则，该方法不执行任何操作并返回

• public final void setPriority(int priority)

  更改线程的优先级

• public static void sleep(long millisec)

  在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响

• public static void yield()

  暂停当前正在执行的线程对象，并执行其他线程

• public final void join(long millisec)

  等待该线程终止的时间最长为 millisec 毫秒

• public final boolean isAlive()

  测试线程是否处于活动状态

• public static Thread currentThread()

  返回对当前正在执行的线程对象的引用

• public final void setDaemon(boolean on)

  将该线程标记为守护线程或用户线程

停止线程

不推荐使用 JDK 提供的 stop()、destroy() 方法。【@Deprecated】

推荐线程自己停止下来：

• 建议定义一个标识为终止变量，对外提供方法改变标识

/**
 * 代码示例
 */
public class Demo implements Runnable {

    private boolean flag = true;


    @Override
    public void run() {
        while(flag) {
            // do something
        }
    }

    public void stop() {
        this.flag = false;
    }

}

线程休眠 sleep()

• sleep(long millisec) 指定当前线程阻塞的毫秒数
• sleep() 存在异常 InterruptedException
• sleep() 时间达到后线程进入就绪状态
• 每一个对象都有一个锁，sleep() 不会释放锁

线程礼让 yield()

• 让当前正在执行的线程暂停（但不阻塞）

• 将线程从运行状态转为就绪状态

• 礼让不一定成功

线程强制执行 join()

join() 合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

• 类似插队现象

线程优先级

Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从 1~10：

• Thread.MIN_PRIORITY = 1;

• Thread.MAX_PRIORITY = 10;

• Thread.NORM_PRIORITY = 5;

使用以下方式获取或改变优先级

• int getPriority()
• void setPriority(int newPriority)

优先级的设定建议在 start() 调度前

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

守护线程（daemon）

线程分为用户线程和守护线程

• 虚拟机必须确保用户线程执行完毕

• 虚拟机不用等待守护线程执行完毕

void setDaemon(boolean on)：将此线程标记为守护进程线程或用户线程。（默认为用户线程）

• 当运行的线程都是守护进程线程时，Java 虚拟机退出。

4. 线程同步

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，此时就需要引入线程同步。

• 线程同步其实是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

由于同一进程的多个线程共享同一块存储空间，带来方便的同时，也带来了访问冲突问题。

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized）

当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题 :

• 一个线程持有锁会导致其他所有需要此锁的线程挂起；
• 在多线程竞争下 , 加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

同步方法

由于可以通过 private 关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是 synchronized 关键字

synchronized 包括两种用法：

• synchronized 方法

  • 同步方法：public synchronized void method(int args) {}

  • synchronized 方法控制对”对象”的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

  • 若将一个大的方法申明为 synchronized 将会影响效率

• synchronized 块

  • 同步块：synchronized(Obj) {}

    • Obj 称之为同步监视器

    • Obj 可以是任何对象 , 但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是 this，就是这个对象本身，或者是 class

同步监视器的执行过程：

1. 第一个线程访问，锁定同步监视器，执行其中代码；
2. 第二个线程访问，发现同步监视器被锁定，无法访问；
3. 第一个线程访问完毕，解锁同步监视器；
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

synchronized 保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性。

JUC 工具类

死锁

两个或两个以上的线程持有不同系统资源的锁，线程彼此都等待获取对方的锁来完成自己的任务，但是没有让出自己持有的锁，线程就会无休止等待下去。

死锁产生的四个必要条件：

1. 互斥使用

   当资源被一个线程使用（占有）时，别的线程不能使用

2. 不可抢占

   资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放

3. 请求和保持

   当资源请求者在请求其他的资源的同时保持对原有资源的占有

4. 循环等待

   即存在一个等待队列：P1 占有 P2 的资源，P2 占有 P3 的资源，P3 占有 P1 的资源，这样就形成了一个等待环路

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

Lock 锁

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

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

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

ReentrantLock 属于可重入锁。

示例代码：

class Ticket implements Runnable {

    private int nums = 10;
    ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            // 加锁
            lock.lock();
            try {
                if (nums > 0) {
                    System.out.println(nums--);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                } else {
                    return;
                }
            } finally {
                // 释放锁
                lock.unlock();
            }

        }
    }

}

如果同步代码有异常，要将 unlock() 写入 finally 语句块中。

synchronized 与 Lock 的对比

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

5. 线程协作

经典问题：生产者消费者问题

在生产者消费者问题中 , 仅有 synchronized 是不够的：

• synchronized 可阻止并发更新同一个共享资源 , 实现了同步
• synchronized 不能用来实现不同线程之间的消息传递（通信）

Java 提供了几个方法解决线程之间的通信问题：

方法名	作用
wait()	表示线程一直等待，直到其他线程通知（与 sleep() 不同，wait() 会释放锁）
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程 , 优先级别高的线程优先调度

注意：均是 Object 类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常 IllegalMonitorStateException

解决方式

1. 管程法

   生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

   示例代码：

   public class Demo {
   
       public static void main(String[] args) {
           BufferZone bufferZone = new BufferZone();
           Producer producer = new Producer(bufferZone);
           Consumer consumer = new Consumer(bufferZone);
   
           producer.start();
           consumer.start();
       }
   
   }
   
   class Chicken {
   
       int id;
   
       public Chicken(int id) {
           this.id = id;
       }
   
   }
   
   class BufferZone {
   
       Chicken[] chickens = new Chicken[10];
       int count = 0;
   
       public synchronized void add(Chicken chicken) {
           if (count == chickens.length) {
               try {
                   this.wait();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           chickens[count++] = chicken;
           System.out.println("生产了第" + chicken.id + "只鸡");
           this.notify();
       }
   
       public synchronized void remove(Chicken chicken) {
           if (count == 0) {
               try {
                   this.wait();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
           chickens[--count] = chicken;
           System.out.println("消费了第" + chicken.id + "只鸡");
           this.notify();
       }
   
   }
   
   class Producer extends Thread {
   
       BufferZone bufferZone;
   
       public Producer(BufferZone bufferZone) {
           this.bufferZone = bufferZone;
       }
   
       @Override
       public void run() {
           for (int i = 1; i < 100; i++) {
               bufferZone.add(new Chicken(i));
           }
       }
   
   }
   
   class Consumer extends Thread {
   
       BufferZone bufferZone;
   
       public Consumer(BufferZone bufferZone) {
           this.bufferZone = bufferZone;
       }
   
       @Override
       public void run() {
           for (int i = 1; i < 100; i++) {
               bufferZone.remove(new Chicken(i));
           }
       }
   
   }

2. 信号灯法

示例代码：

public class Demo {

    public static void main(String[] args) {
        CopyMethod copyMethod = new CopyMethod();
        Original original = new Original(copyMethod);
        Copy copy = new Copy(copyMethod);

        original.start();
        copy.start();
    }

}

/**
 * 模拟复制文件数据
 */
class CopyMethod {

    boolean flag = true;

    public synchronized void readIO() {
        // 使用 while 防止虚假唤醒
        while (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("文件--->读入数据" + "--->程序");
        flag = !flag;
        this.notifyAll();
    }

    public synchronized void writeIO() {
        // 使用 while 防止虚假唤醒
        while (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("程序--->写出数据" + "--->文件");
        flag = !flag;
        this.notifyAll();
    }

}

class Original extends Thread {

    CopyMethod copyMethod;

    public Original(CopyMethod copyMethod) {
        this.copyMethod = copyMethod;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            copyMethod.readIO();
        }
    }

}

class Copy extends Thread {

    CopyMethod copyMethod;

    public Copy(CopyMethod copyMethod) {
        this.copyMethod = copyMethod;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            copyMethod.writeIO();
        }
    }

}

务必使用 while 代替 if 条件判断，wait() 要始终保证在while循环当中，防止虚假唤醒。

虚假唤醒：

当一个线程调用同步对象的 wait() 方法后，当前线程会：

1. 释放CPU
2. 释放对象锁
3. 只有等待该同步对象调用 notify() / notifyAll() 该线程才会被唤醒，唤醒后继续从 wait() 处的下一行代码开始执行

这里最关键的就是唤醒后继续从wait处的下一行代码开始执行，这意味着：

• 如果使用 if，条件判断只进行一次，下次被唤醒的时候已经绕过了条件判断，从 wait() 后的语句开始顺序执行；
• 如果使用 while，wait() 后的语句在循环体内，虽然绕过了上一次的条件判断，但终究会进入下一轮条件判断。

参考资料：Java多线程之虚假唤醒（原创）

6. 线程池

• 背景

  经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

• 思路

  提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

  类似生活中的公共交通工具。

• 好处

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

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

  便于线程管理(…)

  • corePoolSize：核心线程数，当线程数小于核心线程数时，线程池优先通过创建核心线程去处理任务

  • maximumPoolSize：线程池中允许的最大线程数

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

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

• ExecutorService：真正的线程池接口。

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

  • <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行 Callable

  • void shutdown()：关闭连接池

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