Java多线程基础

Roger_wh

已于 2022-03-18 14:11:15 修改

阅读量1.6k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： JavaEE 文章标签： java 开发语言

于 2022-03-14 21:12:16 首次发布

本文链接：https://blog.youkuaiyun.com/RogerLuoji/article/details/123488650

JavaEE 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了Java中的多线程概念，包括线程的创建、Thread类常用方法、线程安全问题及其解决策略如同步代码块和同步方法，以及线程通信、线程池的应用，如ThreadPoolExecutor和Executors工具类。此外，还讨论了定时器的两种实现方式以及并发并行的概念，最后讲解了线程的生命周期和状态转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、线程概述

1.1 什么是线程

线程（thread）是一个程序内部的一条执行路径。
main方法的执行是一条单独的执行路径。
程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

1.2 什么是多线程

多线程是指从软硬件上实现多条执行流程的技术。

二、多线程的创建

2.1 继承Thread类

Java是通过java.lang.Thread类来代表线程的。
按照面向对象的思想，Thread类提供了实现多线程的方式。
过程：
1. 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
2. 创建MyThread类的对象
3. 调用线程对象的start()方法启动线程（启动后还是执行run方法）
优点：编码简单
缺点：线程类已经继承Thread类，无法继承其他类，不利于扩展
为什么不调用run方法，而是调用start？
- 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
- 只有调用start方法才是启动一个新的线程执行。
主线程任务应该放在子线程之后。

/**
 * 多线程的创建方式一：继承Thread类
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程（执行run）
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出：" + i);
        }
    }
}
//1.定义一个线程类继承Thread类
class MyThread extends Thread {
    //2.重写run方法，定义线程功能
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}

2.2 实现Runnable接口

过程：
1. 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法。
2. 创建MyRunnable任务对象。
3. 把MyRunnable任务对象交给Thread处理。
4. 调用线程对象的start()方法启动线程。
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

/**
 * 多线程的创建方式二：实现Runnable接口
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        MyRunnable task = new MyRunnable();
        //4.将任务对象交给线程对象Thread处理
        Thread t = new Thread(task);
        //5.启动线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程输出：" + i);
        }
    }
}
//1.定义一个线程类，实现Runnable接口
class MyRunnable implements Runnable {
    //2.重写run方法，定义线程任务
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程输出：" + i);
        }
    }
}

2.3 实现Callable接口

前2种线程创建方式都存在一个问题：
- 他们重写的run方法均不能直接返回结果
- 不适合需要返回线程执行结果的业务场景
过程
1. 得到任务对象
  1. 定义类实现Callable接口，重写call方法，封装要做的事情
  2. 用FutureTask把Callable对象封装成线程任务对象
2. 把线程任务对象交给Thread处理
3. 调用Thread的start方法启动线程，执行任务
4. 线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果
FutureTask
- public FutureTask<>(Callable call)：把Callable对象封装成FutureTask对象
- public V get()：获取线程执行call方法返回结果
优点：
- 线程任务类只是实现接口，可以继续继承类的实现接口，扩展性强
- 可以在线程执行完毕后去获取线程执行的结果
缺点：编码稍微复杂

/**
 * 多线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class threadDemo3 {
    public static void main(String[] args) {
        //3.创建Callable任务对象
        Callable call1 = new MyCallable(100);
        //4.把Callable任务对象，交给FutureTask对象(实现了Runnable接口，可以调用get方法得到线程执行结果)
        FutureTask<String> f1 = new FutureTask<String>(call1);
        //5.交给线程执行
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();
        //3.创建Callable任务对象
        Callable call2 = new MyCallable(200);
        //4.把Callable任务对象，交给FutureTask对象(实现了Runnable接口，可以调用get方法得到线程执行结果)
        FutureTask<String> f2 = new FutureTask<String>(call2);
        //5.交给线程执行
        Thread t2 = new Thread(f2);
        //6.启动线程
        t2.start();
        try {
            String rs1 = f1.get();
            System.out.println("第一个线程执行结果: " + rs1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        try {
            String rs2 = f2.get();
            System.out.println("第二个线程执行结果: " + rs2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.定义一个任务类，实现Callable接口(声明线程任务执行完毕后返回结果的数据类型)
class MyCallable implements Callable<String>{
    //2.重写call方法(任务方法)
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;
        } 
        return "子线程的执行结果是： " + sum;
    }
}

三、Thread类的常用方法

3.1 设置名称

获取线程名称：getName()
设置线程名称：setName()
获取当前线程对象：currentThread()

3.2 线程休眠方法

public static void sleep(long time)：让当前线程休眠指定的时间后再继续执行，单位为毫秒。

public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            System.out.println("输出: " + i);
            if(i == 3){
                //让当前线程进入休眠
                Thread.sleep(3000);
            }
        }
    }
}

四、线程安全

4.1 线程安全问题

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，成为线程安全问题
线程安全问题出现的原因
- 存在多线程并发
- 同时访问共享资源
- 存在修改共享资源

4.2 线程安全问题模拟

ThreadDemo.java

/**
 * 模拟取钱案例
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.定义线程类，创建一个共享的账户对象
        Account acc = new Account("share",100000);
        //2.创建两个线程对象，代表小明和小红同时进入
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}

Account.java

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 void drawMoney(double money) {
        String name  = Thread.currentThread().getName();
        if (this.money >= money){
            System.out.println(name + "来取钱成功，吐出: " + money);
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else{
            System.out.println(name + "取钱失败");
        }
    }
}

DrawThread.java

/**
 * 取钱的线程类
 */
public 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);
    }
}

执行结果

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

五、线程同步

5.1 线程同步概述

为了解决线程安全问题
线程同步的核心思想：加锁，把共享资源进行上锁，每次只能一个线程进入访问，访问完毕以后解锁，然后其他线程才能进来。

5.2 方式一：同步代码块

作用：把出现线程安全问题的核心代码给上锁
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行
锁对象的规范要求
- 规范：建议使用共享资源作为锁对象
- 对于实例方法建议使用this作为锁对象
- 对于静态方法建议使用字节码(类名.class)对象作为锁对象

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

5.2 方式二：同步方法

作用：把出现线程安全问题的核心方法给上锁
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行
底层原理
- 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
- 实例方法：默认用this作为所的对象
- 静态方法：默认用类名.class作为锁的对象

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

5.3 方式三：Lock锁

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

六、线程通信

线程通信：线程间相互发送数据
线程通信常见形式
- 通过共享一个数据的方式实现
- 根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做
线程通信实际应用模型
- 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据
- 一般要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己
线程通信案例模拟

Object类的等待和唤醒方法
- void wait()：让当前线程等待并释放所占锁，知道另一个线程调用notify()方法或notifyAll()方法
- void notify()：唤醒正在等待的单个线程
- void notifyAll()：唤醒正在等待的所有线程

/**
 * 目标：模拟线程通信
 */
public class Phone {
    //实现线程间通信：默认手机当前处于来电提醒
    private boolean flag = false;
    public void run() {
        //a.负责来电提醒的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        synchronized (Phone.this) {
                            if (flag) {
                                // 此时应该接电话
                            } else {
                                // 代表要来电提醒了
                                System.out.println("有电话呼入");
                                flag = true;
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //b.接电话线程，正式接听了
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //不断接听电话
                    while (true) {
                        synchronized (Phone.this) {
                            if (flag) {
                                //可以接听电话
                                System.out.println("电话接听中，通话5秒钟");
                                Thread.sleep(5000);
                                flag = false; //代表要继续等待呼入电话
                                //唤醒别人,等待自己，
                            }
                            Phone.this.notify();
                            Phone.this.wait();
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
    public static void main(String[] args) {
        //1.创建1部手机
        Phone huawei = new Phone();
        huawei.run();
    }
}

七、线程池

7.1 线程池概述

线程池：一个可以复用线程的技术
不用线程池的问题：如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新现成的开销是很大的。

7.2 线程池实现的API、参数说明

谁代表线程池：JDK5.0起提供了代表线程池的接口：ExecutorService
如何得到线程池对象
- 方式一：使用EXecutorService的实现类ThreadPoolExecutor创建一个线程池对象
- 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

7.2.1 ThreadPoolExecutor

ThreadPoolExecutor构造器参数说明

public ThreadPoolExecutor(int corePoolSize,\\线程池核心线程数量
                          int maximumPoolSize,\\线程池可支持的最大线程数
                          long KeepAliveTime,\\临时线程的最大存活时间
                          TimeUnit unit,\\存活时间的单位
                          BlockingQueue<Runnable> workQueue,\\制定任务队列
                          ThreadFactory threadFactory,\\制定创建线程的线程工厂
                          RejectedExecutionHandler handler\\制定拒绝策略                       
)

新任务提交时，核心线程和任务队列都满了，但是线程池还没有满的时候，可以创建临时线程
新任务提交时，任务线程、任务队列、线程池都满了，会拒绝任务

7.3 线程池处理Runnable任务

ThreadPoolDemo1.java

/**
 * 自定义一个线程池对象，并测试其特性
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        // 1.创建线程池对象
        /**
         * int corePoolSize,
         * int maximumPoolSize,
         * long keepAliveTime,
         * TimeUnit unit,
         * BlockingQueue<Runnable> workQueue,
         * ThreadFactory threadFactory,
         * RejectedExecutionHandler handler)
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        // 2.任务交给线程池处理
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        
        //pool.shutdownNow();//立即关闭，会丢失任务
        pool.shutdown();//会等待全部任务执行完毕之后再关闭
    }
}

MyRunnable.java

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了:HelloWorld" + i);
            try {
                System.out.println("此线程开始休眠");
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果

pool-1-thread-2输出了:HelloWorld0
此线程开始休眠
pool-1-thread-5输出了:HelloWorld0
此线程开始休眠
pool-1-thread-4输出了:HelloWorld0
此线程开始休眠
pool-1-thread-1输出了:HelloWorld0
此线程开始休眠
pool-1-thread-3输出了:HelloWorld0
此线程开始休眠

7.4 线程池处理Callable任务

MyCallable.java

class MyCallable implements Callable<String>{
    //2.重写call方法(任务方法)
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "执行1-" + n + "的求和结果是： " + sum;
    }
}

ThreadPoolDemo2.java

/**
 * 线程池处理Callable任务
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1.创建线程池对象
        /**
         * int corePoolSize,
         * int maximumPoolSize,
         * long keepAliveTime,
         * TimeUnit unit,
         * BlockingQueue<Runnable> workQueue,
         * ThreadFactory threadFactory,
         * RejectedExecutionHandler handler)
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        // 2.任务交给线程池处理
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        Future<String> f5 = pool.submit(new MyCallable(500));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
    }
}

执行结果

pool-1-thread-1执行1-100的求和结果是： 4950
pool-1-thread-2执行1-200的求和结果是： 19900
pool-1-thread-3执行1-300的求和结果是： 44850
pool-1-thread-3执行1-400的求和结果是： 79800
pool-1-thread-3执行1-500的求和结果是： 124750

7.5 EXecutors工具类实现线程池

ThreadPoolDemo3.java

/**
 * 使用Executors的工具方法直接得到线程池
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //1.创建固定数量线程的线程池
        ExecutorService pool =  Executors.newFixedThreadPool(3);
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
    }
}

Executors不适合做大型互联网场景的线程池方案，建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险

八、定时器

8.1 定时器概述

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

8.2 定时器实现方式一：Timer

public void Timer：创建Timer定时器对象
public void schedule(TimerTask task,long delay,long period)：开启一个定时器，按照计划处理TimerTask任务
特点和存在的问题
- Timer是单线程，处理多个任务按照顺序执行，存在延时，与设置定时器的时间有出入
- 可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续线程任务执行

TimerDemo1

/**
 * Timer定时器的使用和了解
 */
public class TimerDemo1 {
    public static void main(String[] args) {
        // 1、创建Timer定时器
        Timer timer = new Timer(); //定时器本身就是一个线程
        // 2、调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行一次");
            }
        }, 3000, 2000);
    }
}

8.3 定时器实现方式二：ScheduledExecutorService

ScheduledExecutorService是jdk1.5引入的并发包，目的是弥补Timer的缺陷，ScheduledExecutorService内部为线程池
public static ScheduledE xecutorService newScheduledThreadPool(int corePoolSize)：得到线程池对象
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)：周期调度方法
ScheduledExecutorService的优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行

TimeDemo2.java

/**
 * ScheduledExecutorService定时器的使用和了解
 */
public class TimerDemo2 {
    public static void main(String[] args) {
        // 1、创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);
        // 2、开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出： AAA");
            }
        },0,2000, TimeUnit.SECONDS);
    }
}

九、并发、并行

正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。
并发的理解：
- CPU同时处理线程的数量有限
- CPU会轮询为系统的每个线程服务，由于CPU的切换速度很快，给我们的感觉这些线程在同时执行，这就是并发
并行的理解：
- 在同一个时刻，同时有多个线程在被CPU处理并执行

十、线程的生命周期

线程的状态
- 线程从生到死的过程，以及中间经历的各种状态及状态转换
- 理解线程的状态有利于提升并发编程的理解能力
Java线程的状态
- Java共定义了六种状态，都在Thread类的内部枚举类中
  - NEW
  - RUNNABLE
  - BLOCKED
  - WAITING
  - TIMED_WAITING
  - TERMINATED