Java 多线程

🍎个人主页：亮点的博客
🍊个人信条：理想如果不向现实做一点点屈服，那么理想也将归于尘土
🍑刷题专栏：【Java】牛客网刷题
🥭刷题网站：牛客网 学习的一种有效途径就是刷题，丰富的做题经验可以加深对知识点的理解，推荐一款刷题网站，赶快点击这里注册学习吧👉你的进阶之路！

---

---

前言

什么是线程？

• 线程(thread)是一个程序内部的一条执行路径。
• 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
• 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。
• 多线程是指从软硬件上实现多条执行流程的技术。

学习内容

• 多线程的创建
• Thread类的常用方法
• 线程安全、线程同步
• 线程通信、线程池
• 定时器、线程状态等

---

1、多线程的创建

• Java是通过java.lang.Thread 类来代表线程的。
• 按照面向对象的思想，Thread类应该提供了实现多线程的方式。

（1）方式一：继承Thread类

• ① 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

• ② 创建MyThread类的对象

• ③ 调用线程对象的start()方法启动线程（启动后还是执行run方法的）直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。 l 只有调用start方法才是启动一个新的线程执行。

• 优点：编码简单

• 缺点：线程类已经继承Thread，无法继承其他类，不利于扩展

（2）方式二：实现Runnable接口

• ① 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
• ② 创建MyRunnable任务对象
• ③ 把MyRunnable任务对象交给Thread处理。
• ④ 调用线程对象的start()方法启动线程

Thread的构造器

• 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
• 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

实现Runnable接口(匿名内部类形式)

• ① 可以创建Runnable的匿名内部类对象。
• ② 交给Thread处理。
• ③ 调用线程对象的start()启动线程。

（3）方式三：JDK 5.0新增：实现Callable接口

利用Callable、FutureTask接口实现

• ① 得到任务对象
  （1） 定义类实现Callable接口，重写call方法，封装要做的事情。
  （2） 用FutureTask把Callable对象封装成线程任务对象。
• ② 把线程任务对象交给Thread处理。
• ③ 调用Thread的start方法启动线程，执行任务
• ④ 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

FutureTask的API

• 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
• 可以在线程执行完毕后去获取线程执行的结果。
• 缺点：编码复杂一点

总结

2、Thread的常用方法

Thread获取和设置线程名称

Thread类获得当前线程的对象

注意：

• 此方法是Thread类的静态方法，可以直接使用Thread类调用。
• 这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。

Thread的构造器

3、线程安全

线程安全问题出现的原因？

• 存在多线程并发
• 同时访问共享资源
• 存在修改共享资源

案例：取钱业务

需求： 小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。

分析：

• ①：需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
• ②：需要定义一个线程类，线程类可以处理账户对象
• ③：创建2个线程对象，传入同一个账户对象。
• ④：启动2个线程，去同一个账户对象中取钱10万

代码如下：

class Account {
    private String cardId;
    private double money; // 账户的余额

    public Account(){

    }
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    //取钱
    public void drawMoney(double money) {
        // 0、先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        // 1、判断账户是否够钱
        if(this.money >= money){
            // 2、取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            // 3、更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else {
            // 4、余额不足
            System.out.println(name +"来取钱，余额不足！");
        }
    }
    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
}
class DrawThread extends Thread {
    // 接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 小明 小红：取钱
        acc.drawMoney(100000);
    }
}
public class ThreadDemo{
    public static void main(String[] args) {
        // 1、定义线程类，创建一个共享的账户对象
        Account acc = new Account("ICBC-111", 100000);

        // 2、创建2个线程对象，代表小明和小红同时进来了。
        new DrawThread(acc, "小明").start();
        new DrawThread(acc, "小红").start();
    }
}

运行结果:

小红来取钱成功，吐出：100000.0
小红取钱后剩余：0.0
小明来取钱成功，吐出：100000.0
小明取钱后剩余：-100000.0

4、线程同步

（1）同步思想概述

线程同步：为了解决线程安全问题。

1、取钱案例出现问题的原因？

多个线程同时执行，发现账户都是够钱的。

2、如何才能保证线程安全呢？

让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的核心思想

• 加锁，把共享资源进行上锁，每次只能一个进程进入访问完毕以后解锁，然后其他进程才能进来。（加锁：让多个线程实现先后依次访问共享资源）

（2）方式一：同步代码块

• 作用：把出现线程安全问题的核心代码给上锁。
• 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

synchronized(同步锁对象) {
	操作共享资源的代码(核心代码)
}

锁对象要求

• 理论上，锁对象只要对于当前同时执行的线程来说是同一个对象即可。

锁对象的规范要求

• 规范上：建议使用共享资源作为锁对象。
• 对于实例方法建议使用this作为锁对象。
• 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

示例：

public class Account {
    private String cardId;
    private double money; // 余额 关键信息

    public Account() {
    }
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
//    // 100个线程人
//    public static void run(){
//        synchronized (Account.class){
//
//        }
//    }
    public void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 同步代码块
        // 小明 小红
        // this == acc 共享账户
        synchronized (this) {
            // 2、判断余额是否足够
            if(this.money >= money){
                // 钱够了
                System.out.println(name+"来取钱，吐出：" + money);
                // 更新余额
                this.money -= money;
                System.out.println(name+"取钱后，余额剩余：" + this.money);
            }else{
                // 3、余额不足
                System.out.println(name+"来取钱，余额不足！");
            }
        }
    }
}

（3）方式二：同步方法

• 作用：把出现线程安全问题的核心方法给上锁。
• 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

修饰符 synchronized 返回值类型 方法名称(形参列表) {
	操作共享资源的代码
}

同步方法底层原理

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
• 如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

示例：

public class Account {
    private String cardId;
    private double money; // 余额 关键信息

    public Account() {
    }
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }

    public synchronized void drawMoney(double money) {
        // 1、拿到是谁来取钱
        String name = Thread.currentThread().getName();
        // 2、判断余额是否足够
        // 小明  小红
        if(this.money >= money){
            // 钱够了
            System.out.println(name+"来取钱，吐出：" + money);
            // 更新余额
            this.money -= money;
            System.out.println(name+"取钱后，余额剩余：" + this.money);
        }else{
            // 3、余额不足
            System.out.println(name+"来取钱，余额不足！");
        }
    }
}

（4）方式三：Lock锁

Lock锁

• 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，更加灵活、方便。
• Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
• Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

Lock的API

5、线程通信[了解]

什么是线程通信、如何实现？

• 所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

线程通信常见形式

• 通过共享一个数据的方式实现。
• 根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信实际应用场景

• 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。
• 要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

6、线程池[重点]

（1）线程池概述

什么是线程池

• 线程池就是一个可以复用线程的技术。

不使用线程池的问题

• 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

（2）线程池实现的API、参数说明

谁代表线程池？

• JDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象

• 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
• 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器的参数说明

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

说明

• 参数一：指定线程池的线程数量（核心线程）： corePoolSize 不能小于0
• 参数二：指定线程池可支持的最大线程数： maximumPoolSize 最大数量 >= 核心线程数量
• 参数三：指定临时线程的最大存活时间： keepAliveTime 不能小于0
• 参数四：指定存活时间的单位(秒、分、时、天)： unit 时间单位
• 参数五：指定任务队列： workQueue 不能为null
• 参数六：指定用哪个线程工厂创建线程： threadFactory 不能为null
• 参数七：指定线程忙，任务满的时候，新任务来了怎么办： handler 不能为null

（3）线程池处理Runnable任务

ThreadPoolExecutor创建线程池对象示例

ExecutorService pools = new ThreadPoolExecutor(3, 5
            , 8 , TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
            Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());

ExecutorService的常用方法

新任务拒绝策略

（4）线程池处理Callable任务

ExecutorService的常用方法

线程池如何处理Callable任务，并得到任务执行完后返回的结果

• 使用ExecutorService的方法；
• Future submit(Callable command)

（5）Executors工具类实现线程池

Executors得到线程池对象的常用方法

• Executors：线程池的工具类通过调用方法返回不同类型的线程池对象

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

Executors使用可能存在的陷阱

• 大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

Executors工具类底层是基于什么方式实现的线程池对象？

• 线程池ExecutorService的实现类：ThreadPoolExecutor 2.

Executors是否适合做大型互联网场景的线程池方案？

• 不合适。
• 建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规 则，规避资源耗尽的风险

7、补充知识

（1）定时器

• 定时器是一种控制任务延时调用，或者周期调用的技术。
• 作用：闹钟、定时邮件发送。

定时器的实现方式

• 方式一：Timer
• 方式二： ScheduledExecutorService

Timer定时器的特点和存在的问题

• 1、Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。
• 2、可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

ScheduledExecutorService定时器

• ScheduledExecutorService是 jdk1.5中引入了并发包，目的是为了弥补Timer的缺陷, ScheduledExecutorService内部为线程池。

ScheduledExecutorService的优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行。

（2）并发、并行

并发与并行

• 正在运行的程序（软件）就是一个独立的进程， 线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发的理解

• CPU同时处理线程的数量有限。
• CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

• 在同一个时刻上，同时有多个线程在被CPU处理并执行

（3）线程的生命周期

线程的状态

• 线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
• 理解线程的状态有利于提升并发编程的理解能力。

Java线程的状态

• Java总共定义了6种状态
• 6种状态都定义在Thread类的内部枚举类中。

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

线程的6种状态互相转换

总结

---

和我一起来刷题学习吧！传送门👉牛客网-求职|面试|学习

---

看到最后，点个赞吧！