【JAVA高级&并发编程】多线程篇

【JAVA高级&并发编程】多线程篇

概述

本篇笔记将对 JAVA 的多线程相关的内容进行复回顾、复盘、总结

"温故而知新"

目录

多线程篇

0x01:基本概念:程序、进程、线程

  • 程序(program):

    是为完成特定任务、用某种语言编写的一组指令的集合。即指 一段静态的代码,静态对象。

  • 进程(process):

    是程序的一次执行过程,或是 正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程(生命周期)

    • 如:运行中的 QQ,运行中的 MP3播放器
    • 程序是静态的,进程是动态的
    • 进程作为资源分配的单位, 系统在运行时会为每个进程分配不同的内存区域
  • 线程(thread):

    • 进程可进一步细化为线程,是一个程序内部的一条执行路径。
    • 若一个进程同一时间并行执行多个线程,就是支持多线程的
    • 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器 (pc),线程切换的开销小。
    • 一个进程中的多个线程 共享相同的内存单元/内存地址空间,它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来 安全的隐患。

如何理解单核CPU和多核CPU?

  • 单核 CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。
  • 例如:虽然有多车道,但是收费站只有一个工作人员在收费,只有收了费才能通过,那么 CPU 就好比收费人员。如果有某个人不想交钱, 那么收费人员可以把他“挂起”(晾着他,等他想通了,准备好了钱,再去收费。但是因为 CPU 时间单元特别短,因此感觉不出来。
  • 如果是多核的话,则表示有多个工作人员可以同时处理多个任务,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
  • 一个 Java 应用程序 java.exe,其实至少有三个线程: main() 主线程, gc() 垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。

并行与并发的区别是什么?

  • 并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
  • 并发:一个CPU(采用时间片) “同时” 执行多个任务。比如:秒杀抢购、多个人做同一件事。

那么多线程有哪些优点?
以单核 CPU 为例, 只使用单个线程先后完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?

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

什么时候需要用到多线程?

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

0x02:线程的创建和使用

  • Java 语言的 JVM 允许程序运行多个线程,它通过 java.lang.Thread 类来体现。
  • Thread 类的特性
    • 每个线程都是通过某个特定的 Thread 对象的 run() 方法来完成操作的,经过把 run() 方法的主体称为 线程体
    • 通过该 Thread 对象的 start() 方法来启动这个线程,而非直接调用 run() 方法。

Thread 类的构造器

  • Thread(): 创建新的 Thread 对象
  • Thread(String threadname): 创建线程并指定线程实例名
  • Thread(Runnable target): 指定创建线程的目标对象,它实现了 Runnable
    口中的 run 方法
  • Thread(Runnable target, String name): 创建新的 Thread 对象

方式一:继承于 Thread 类

  • 1、创建一个继承于 Thread 类的子类
  • 2、重写 Thread 类的 run() ,并且将此线程需要执行的操作声明在 run() 方法中
  • 3、创建 Thread 类的子类的对象
  • 4、通过此对象调用 start()

通过下面的代码,理解如何通过该方式来创建多线程

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //再启动一个线程,遍历100以内的偶数。
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();
     
        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "**main()**");
            }
        }
    }

}

执行结果如下

image.png

需要注意的一些问题

  • 我们不能通过直接调用 run() 的方式启动线程,如果自己手动调用 run() 方法,那么就只是普通方法,没有启动多线程模式
  • run() 方法由 JVM 调用,什么时候调用,执行的过程控制都有操作系统的 CPU 调度决定。
  • 一个线程对象只能调用一次 start() 方法启动,如果重复调用了,则将抛出
    异常 IllegalThreadStateException

小练习:创建两个分线程,其中一个线程遍历 100 以内的偶数,另一个线程遍历 100 以内的奇数

  • 创建两个线程,分别处理不同的事
  • 通过匿名子类的方式创建多线程
public class ThreadDemo {
    public static void main(String[] args) {
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);

                    }
                }
            }
        }.start();
        
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);

                    }
                }
            }
        }.start();
    }
}

Thread类常用的方法

  • start(): 启动当前线程,并且调用当前线程的 run() 方法
  • run(): 通常需要重写 Thread 类中的此方法,将创建的线程要执行的操作声明在此方法中
  • currentThread(): 静态方法,返回执行当前代码的线程
  • getName(): 获取当前线程的名字
  • setName(): 设置当前线程的名字
  • yield(): 释放当前 cpu 的执行权
  • join(): 在线程 A 中调用线程 Bjoin() 方法时,线程 A 就进入阻塞状态,直到线程 B 完全执行完以后,线程 A 才结束阻塞状态,并继续运行后续的代码。
  • stop(): 此方法已过时。当执行此方法时,强制结束当前线程。
  • sleep(long millitime): 让当前线程“睡眠”指定的 millitime毫秒。在指定的 millitime 毫秒时间内,当前线程是阻塞状态。
  • isAlive(): 判断当前线程是否存活

线程的调度

调度的策略如下

  • 根据时间片进行调度
  • 抢占式:高优先级的线程抢占 CPU

JAVA 的线程调度方法

  • 同优先级的线程组成 “先进先出” 的队列(先到先服务),使用时间篇的策略
  • 对于高优先级的线程,使用优先调度的抢占式策略

线程的优先级

线程的优先级共分为十个等级

  • MAX_PRIORITY: 10
  • MIN _PRIORITY: 1
  • NORM_PRIORITY: 5

涉及到的方法:

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

一些说明:

  • 线程创建时继承浮现出的优先级
  • 低优先级只是获得调度的 概率 低,并非一定是在高优先级之后才被调用

方式二:实现 Runnable 接口

  • 1、创建一个实现了 Runnable 接口的类
  • 2、实现类去实现 Runnable 中的抽象方法:run()
  • 3、创建实现类的对象
  • 4、将此对象作为参数传递到 Thread 类的构造器中,创建 Thread 类的对象
  • 5、通过 Thread 类的对象调用 start()

通过下面的例子,来体会上述的构建过程

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2. 实现类去实现Runnable中的抽象方法:run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start(): ① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();
        //再启动一个线程,遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

比较上述创建线程的两种方式

相同点:两种方式都需要重写 run() 方法,将线程要执行的逻辑声明在 run() 方法内。

但在实际的开发中,我们优先选择以实现 Runnable 接口的方式来创建多线程,为什么?

  • 因为该方式没有类的单继承性的局限,可以继承其他类或者实现多个接口
  • 更适合处理多个线程由共享数据的情况

练习

创建三个窗口卖票,总票数为 100 张,使用 Runnable 接口的方式来实现

/**
 * Author:LCyee
 * Blog: www.codeyee.com
 * Date: 2020/8/31
 * Description: 创建三个窗口卖票,总票数为100张,使用 Runnable 接口的方式来实现
 */
public class RunnableExer {
    public static void main(String[] args) {
        Threader threader = new Threader();
        //创建三个线程
        for (int i = 0; i < 3; i++) {
            new Thread(threader).start();
        }
    }
}

class Threader implements  Runnable{
    private int ticket =  100; //票数

    @Override
    public void run() {
        //模拟购票操作
        while (ticket > 0) {
            ticket--;
            System.out.println(Thread.currentThread().getName() + ":buy ticket " + ticket);
        }
    }
}

运行结果

Thread-2:buy ticket 97
Thread-0:buy ticket 98
Thread-0:buy ticket 95
Thread-0:buy ticket 94
Thread-0:buy ticket 93
Thread-0:buy ticket 92
Thread-0:buy ticket 91
Thread-0:buy ticket 90
Thread-0:buy ticket 89
Thread-0:buy ticket 88
Thread-0:buy ticket 87
Thread-0:buy ticket 86
Thread-1:buy ticket 97
Thread-0:buy ticket 85
Thread-2:buy ticket 96
Thread-2:buy ticket 82
Thread-2:buy ticket 81
Thread-2:buy ticket 80
......

通过上述的代码,实现了该练习题的需求,但是以这样的方式去实现并发购票的需求是线程不安全的,可能会出现重复购买的情况,如下

Thread-2:buy ticket 12
Thread-0:buy ticket 13
Thread-0:buy ticket 9
Thread-2:buy ticket 9

在后续的章节中我们再去解决该问题

方式三和方式四为JDK5.0之后新增的线程创建方式

方式三:实现 Callable接口

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

  • 相比 run() 方法,可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助 FutureTask 类,比如获取返回结果
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法,将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

什么是 Future 接口?

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

方式四:线程池

使用背景

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

使用思路

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

有哪些好处?

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理
    • corePoolSize:设置核心池的大小
    • maximumPoolSize:最大线程数
    • KeepAliveTime:线程没有任务时,保持指定的时间后会终止
    • 其他等

使用案例如下

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);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());    //适合适用于Runnable
        // service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

设置线程池的属性

ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) service;
//设置线程池的属性
System.out.println(threadPoolExecutor.getClass());
threadPoolExecutor.setCorePoolSize(15);
threadPoolExecutor.setKeepAliveTime();
  • JDK 5.0 起提供了线程池相关 APIExecutorServiceExecutors

    • ExecutorService

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

    • void execute(Runnable command)

      执行任务/命令,没有返回值,一般用来执行 Runnable

    • Future submit(Callable task)

      执行任务,有返回值,一般又来执行Callable

    • void shutdown()

      关闭连接池

  • Executors:

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

    • Executors.newCachedThreadPool()

      创建一个可根据需要创建新线程的线程池

    • Executors.newFixedThreadPool(n)

      创建一个可重用固定线程数的线程池

    • Executors.newSingleThreadExecutor()

      创建一个只有一个线程的线程池

    • Executors.newScheduledThreadPool(n)

      创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

0x03:线程的生命周期

JDK中用 Thread.State 类定义了线程的几种状态要想实现多线程, 必须在主线程中创建新的线程对象。 Java 语言使用 Thread 类及其子类的对象来表示线程, 在它的一个完整的生命周期中通常要经历如下的五种状态:

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

通过下图来感受一个线程从 新建 到 死亡(销毁)的过程

image.png

0x04:线程的同步

什么是线程安全?

我们以生活中的一个例子来解释这个现象:

假设你的银行卡里面有 3000 块钱(不允许透支),你去银行的ATM机取款,输入了取款的金额 2000 后,此时取款机正在清点钞票,还未扣除你银行卡的余额,但此时你的媳妇在通过网银在网上购买了一个商品,价格也是2000,而由于此时你的银行卡还没有进行扣款,余额还是 3000,之后你也从ATM机取出了 2000 块钱,导致你原本你的余额只有 3000,而却消费了4000

image.png

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

一个例子:模拟火车站售票程序,开启三个窗口售票

class Window1 implements Runnable{

private int ticket = 100;

    @Override
    public void run() {
        while(true){
                if (ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果

Thread-2:buy ticket 3
Thread-2:buy ticket 2
Thread-2:buy ticket 1
Thread-0:buy ticket 32
Thread-1:buy ticket 37
Thread-2:buy ticket 0

Process finished with exit code 0

在上述代码的运行结果当中,线程2购买到了0号的票,表示在票数为 0 时仍然被消费了一次。

如下图所示:

image.png

问题出现的原因:

当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。

如何解决线程安全的问题?

当一个线程 A 在操作 ticket 的时候,其他线程不能参与进来。直到线程 A 操作完 ticket 时,其他线程才可以开始操作 ticket。这种情况即使线程 A 出现了阻塞,也不能被改变。

方式一:同步代码块

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

说明:

  • 1、操作共享数据的代码,即为需要被同步的代码。不能包含代码多了,也不能包含代码少了。
  • 2、共享数据:多个线程共同操作的变量。比如:ticket 就是共享数据。
  • 3、同步监视器,俗称:“锁”。任何一个类的对象,都可以充当锁。

要求:多个线程必须要共用同一把锁(任意类的对象)

具体的例子

class Window1 implements Runnable{
    private int ticket = 100;
    //可以任意的创建一个对象充当锁(同步监视器)
	Object locker = new Object();
    @Override
    public void run() {
//        Object obj = new Object();  //如果在此处去声明锁,则该对象不是唯一的,不能实现同步的效果
        while(true){
            synchronized (locker){ 
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();
        
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

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

@Override
public void run() {
    while(true){
        synchronized (this){ 
            ... ...
        }
    }
}

运行该例子,得到的结果不再出现购买到错票的情况(重复消费、超额消费)等线程安全问题

image.png

通过画图的方式来分析原理

image.png

上述的例子是在基于 Runnable 接口来实现多线程的情况下来使用同步代码块,而基于继承 Thread 类来实现,会有些不同。我们仍参照上述例子的思路,在基于继承 Thread 类的多线程例子中去实现同步代码块

class Window2 extends Thread{
    private static int ticket = 100;
    private Object locker = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (locker){
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

在上述基于继承 Thread实现多线程例子当中,第一个例子的思路,构建任意一个对象 synchornized 代码块的 “锁”来使用,但仍然会出现线程安全的问题。原因是我们通过继承的方式去实现多线程,需要构建多个对象,而这个 “锁”也会被赋值出了很多份,所以这个锁不符合我们上述的“唯一”条件。即使使用 this 作为锁也会出现上述的情况。

解决上述问题的方案有以下几种:

1、将作为“锁”的对象设置成 static ,这样可以使得该“锁”只被创建一次,例如

private static Object locker = new Object();

2、使用 类名.class 例如 Window2 作为“锁”,之所以可以这样使用,是因为 类名.class 本身也是一个对象,并且只会被构建一次,符合“唯一” 的要求,例如

synchronized (Window2.class){
...
}

方式二:同步方法

如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的。

使用方法:

  • 将需要同步操作的代码封装到一个方法里面
  • 并使用 synchronized 关键字修饰该方法
  • 例如:private synchronized Boolean show(){ }

完整的使用案例如下

class Window3 implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            Boolean finished = show();
            if(finished) break;  //线程任务的结束标识
        }
    }

    private synchronized Boolean show(){    //同步监视器:this
        if (ticket == 0) {
            return true;
        }
        try {
            //模拟具体操作的业务逻辑所使用的时间
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
        ticket--;
        return false;
    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

输出结果如下

image.png

上述的使用案例是基于实现 Runnable 接口以及同步方法来实现的多线程以及线程的同步,而在基于继承 Thread 类去实现会有些不同,需要使用 static 关键字将该方法修饰为静态方法。

如下例子所示

  • 例子:private static synchronized void show(){}

原因:非静态的同步方法使用的同步监视器(锁)为 this ,而静态的同步方法使用的是 类名.class 作为同步监视器

关于同步方法的总结:

1、同步方法仍然涉及到同步监视器,只是不需要我们去显式的去声明

2、非静态的同步方法,同步的监视器是:this ,而声明了 static 的静态同步方法,使用的的同步监视器是当前类本身:类名.class

方式三:使用Lock锁

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

什么是 Lock 锁?

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

如何使用?

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

下面我们来看一个具体的使用案例

class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @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);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法:unlock()
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

问题:synchronizedLock 有哪些异同?

相同的:二者都可以解决线程安全问题

不相同:

  • synchronized 机制在执行完相应的同步代码块以后,会自动释放同步监视器
  • 而使用 Lock 锁的方式需要调用 lock() 方法来抢占同步监视器(锁),同时结束同步也需要手动的调用 unlock() 来试放同步监视器(锁),此时其他线程才能进行抢占操作。

上述的三种解决方案,建议优先的使用顺序如下:

  • 1、使用 Lock 锁的方式
  • 2、同步代码块(已经进入了方法体,分配了相应的资源)
  • 3、同步方法(在方法体之外)

线程同步的优缺点

优点:
同步的方式,解决了线程的安全问题。

缺点(局限性):
操作同步代码时,只能有一个线程参与,其他线程等待,相当于是一个单线程的过程,效率低。

切记:要注意线程同步的使用范围

  • 范围太小:没锁住所有有安全问题的代码
  • 范围太大:没发挥多线程的功能。

解决“单例模式”中的线程安全问题

在单例模式中,我们需要提供一个获取对象实例的方法,并且该对象只能被创建一次,因此称为单例模式。但是在多线程的情况下,可能会出现单例对象被实例化多次的情况。

例如,线程 A 进入到创建对象的过程时可能会被 CPU 挂起,此时线程 B 也进入到了该对象创建的环节里,最终可能会导致这个对象被实例化了多次。

所以我们需要通过线程同步的解决方案来实现“线程安全”的单例模式

如下案例所示

方式一:使用同步代码块

public class BankTest {

}

class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static Bank getInstance(){
        synchronized (Bank.class) {
            if(instance == null){
                instance = new Bank();
            }

        }
        return instance;
    }

}

使用 synchronized 构建的同步代码块可以解决单例模式中的线程安全问题,但是效率会稍差一些,为什么效率会差?

因为当多个线程同时调用了 getInstance 来获取实例对象时,当一个线程进入了同步代码块时,其他的线程都需要进行等待,在并发量较大的时候,效率就相对低了很多,我们可以在上面的例子的基础上做出修改,如下代码

public class BankTest {

}

class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static Bank getInstance(){
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

我们可以在进入到 syschronized 代码块之前,判断当前的单例对象是否为 null ,如果不为 null 则表示该对象已经被之前的线程创建了,则无需再进入到同步代码块进行同步等待,因此可以提高效率。

0x05:线程的死锁问题

什么是死锁?

  • 不同的线程间分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁

    例如:两个人吃饭需要用到筷子,但是只有一双筷子,两个人同时拿住        了这双筷子,但是相互都不肯放开手,最终导致两个人都吃不到饭。
    
  • 出现死锁后,不会出现异常,也不会有任何的提示,只是所有的线程都处于阻塞的状态,无法继续。

我们来看下面的一个例子

//死锁的演示
class A {
	public synchronized void foo(B b) { //需要拿到A类的锁
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法");

		//模拟实际业务处理的耗时
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}

		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法");

		//此时A类的锁已经被当前调用A类的foo方法的线程拿住
		//在A类的foo方法中,又调用了B类的last方法,而该方法需要A类的 "锁" 才能结束自己的bar方法
		b.last();
	}

	public synchronized void last() { //需要拿到A类的锁
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {	//B类的锁
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法");

		//模拟实际业务处理的耗时
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}

		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法");

		//此时B类的锁已经被当前调用B类的bar方法的线程拿住
		//在B类的bar方法中,又调用了A类的last方法,而该方法需要B类的 "锁" 才能结束自己的bar方法
		a.last();
	}

	public synchronized void last() {//B类的锁
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	//主方法
	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		
		//创建一个子线程,触发run方法调用B类的bar方法
		new Thread(dl).start();
		
		//主线程运行A类的foo
		dl.init();
	}
}

运行结果如下,主线程和子线程都在执行对方的 last 方法时,相互依赖对方的“锁”才能够结束线程,导致死锁的情况发生

image.png

总结如下:
从上述的例子可以得出,如果在两个(多个)线程之间,相互都依赖了两个(多个)类的“锁”才能继续完成后续的操作,就可能会出现上述死锁的情况。

如何避免死锁的情况?

  • 使用专门的算法、原则等
  • 尽量减少同步资源的定义(synchronized关键字)
  • 尽量避免使用同步资源的嵌套(同步资源中又定义或者调用了另一个同步资源)

0x06:线程的通信

线程通信的例子:使用两个线程打印 1-100。线程1, 线程2 交替打印
这里涉及到三个方法:

  • wait():一旦执行此方法,当前线程会进入到阻塞状态,并释放同步监视器(锁)
  • notify():一旦执行此方法,就会唤醒一个线程,如果有多个线程处于阻塞状态,那么就唤醒优先级最高的那个
  • notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
class Number implements Runnable{
    private int number = 1;
    private Object obj = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj) {
                obj.notify();
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }

        }

    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

执行结果如下

image.png

说明:

  • wait()notify()notifyAll() 三个方法必须使用在同步代码块或同步方法中。
  • 上述的三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则,会出现IllegalMonitorStateException 异常
  • wait()notify()notifyAll() 三个方法是定义在 java.lang.Object 类中。

一些问题:

sleep()wait() 的有哪些异同之处?

  • 相同之处,一旦执行方法,都可以使得当前的线程进入到阻塞状态
  • 不同之处在于:
    • 两个方法声明的位置不同:Thread 类中声明 sleep(), Object 类中声明 wait()
    • 调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
    • 关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep() 不会释放锁,wait() 会释放锁。

经典例题:生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品 (比如20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产,如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。

如下案例

class Clerk{
    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            notify();  //每次生产完就会释放阻塞的消费线程
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;
            notify(); //释放所有阻塞的消费、生产线程
        }else{
            //等待
            try {
                wait();  //阻塞当前线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class Producer extends Thread{//生产者
    private Clerk clerk;
    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品.....");
        while(true){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }

    }
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");

        while(true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();

    }
}

总结

通过本章节的学习,巩固了 JAVA 的多线程的内容,以及复盘了在多线程的实际开发中会遇到的常见的一些问题。

Copyright: 采用 知识共享署名4.0 国际许可协议进行许可

Links: https://codeyee.com/archives/java-thread.html