【Java】多线程

最新推荐文章于 2026-01-01 15:39:09 发布

原创最新推荐文章于 2026-01-01 15:39:09 发布 · 1.2k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java 专栏收录该内容

2 篇文章

订阅专栏

Java多线程基础知识及实现

1. 简介

多线程是指从软件或者硬件上实现多个线程并发执行的技术。
具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

1.1 并发和并行

并行：在同一时刻，有多个指令在多个CPU上同时执行。
并发：在同一时刻，有多个指令在单个CPU上交替执行。

1.2 进程和线程

进程：是正在运行的程序

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
并发性：任何进程都可以同其他进程一起并发执行
线程：是进程中的单个顺序控制流，是一条执行路径
单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序

1.3 线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。
Java中的线程存在6种状态，每种线程状态的含义如下

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

2. 实现多线程

多线程的实现有三种方式，分别是

2.1 方式一：继承Thread类

方法介绍

方法名说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法()
实现步骤
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程
代码示例：

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

//方式一：创建子类继承Thread父类
public class MyThread extends Thread {

   @Override
   public void run() {
       System.out.println("新线程开1始执行");
       for (int i = 100; i < 200; i++) {
           System.out.println("新线程1" + i);

       }
   }

}

public class ThreadDemo1 {
    public static void main(String[] args) {
        MyThread1 myThread = new MyThread();
        myThread1.start();//使用start()方法启动线程后会自动调用run方法。
        for (int i = 0; i < 500; i++) {
            System.out.println(i);
        }
        //可以看到结果中二者（自定义线程和main线程）互相切换运行
    }
}

2.2 方式二：实现Runnable接口

Thread构造方法

方法名说明
Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target, String name) 分配一个新的Thread对象
实现步骤
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程
代码示例

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

//方法2：创建线程任务类，实现Runnable接口
public class MyTask implements Runnable{
    //线程任务功能
    @Override
    public void run() {
        System.out.println("新线程2开始执行");
        for (int i = 100; i < 200; i++) {
            System.out.println("新线程2:" + i);

        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {

        MyTask task1 = new MyTask();
        Thread thread1 = new Thread(task1);
        //可使用lambda表达式简化为（就无需创建MyTask）
//        Thread thread1 = new Thread(()->{
//            System.out.println("新线程2开始执行");
//            for (int i = 100; i < 200; i++) {
//                System.out.println("新线程2:" + i);
//
//            }
//        });
        thread1.start();
        for (int i = 0; i < 500; i++) {
            System.out.println(i);
        }
    }
}

2.3 方式三: 实现Callable接口

方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

实现步骤
- 定义一个类MyCallable实现Callable接口
- 在MyCallable类中重写call()方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 再调用get方法，就可以获取线程结束之后的结果。
代码示例:

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class ThreadDemo4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<>(myCallable);
        Thread t1 = new Thread(ft);
        t1.start();
        Integer result = ft.get();
        System.out.println(result);
    }
}

2.4 三种实现方式的对比

实现Runnable、Callable接口
- 好处: 扩展性强，实现该接口的同时还可以继承其他的类
- 缺点: 编程相对复杂，不能直接使用Thread类中的方法
- 继承Thread类
  - 好处: 编程比较简单，可以直接使用Thread类中的方法
  - 缺点: 可以扩展性较差，不能再继承其他的类

3.线程相关方法

方法介绍

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	具备阻塞作用，等待这个线程死亡才会执行其他线程（挂起其他进程，仅当前进程运行）
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

4. 同步代码块与Lock锁

4.1 简介

使用目的

同步代码块与Lock锁是为了解决多线程环境中有多条语句操作共享数据时产生的安全问题。

基本思路

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

4.2 同步代码块

同步代码块格式：

synchronized(任意对象) { 
  多条语句操作共享数据的代码 
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端
- 好处：解决了多线程的数据安全问题
- 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
示例代码(有同步代码块和同步方法)：

public class PurchaseTicket implements Runnable{

    private int ticketCount =1000;
    Object lock = new Object();//自定义对象
    @Override
    public void run() {
        while(true) {
            if (method()) break;
            /*
               // 上面一行可替换为：
            synchronized (lock) {
                if (ticketCount > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "，" + ticketCount);
                    ticketCount--;
                    if (ticketCount == 0) {
                        break;
                    }
                }

            }
              */

        }
    }
//同步方法，非静态方法使用this锁，静态方法使用类名.class锁
    private synchronized boolean method() {
        if (ticketCount > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "，" + ticketCount);
            ticketCount--;
            if (ticketCount == 0) {
                return true;
            }
        }
        return false;
    }
}

4.3 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock构造方法

方法名说明
ReentrantLock() 创建一个ReentrantLock的实例
加锁解锁方法

方法名说明
void lock() 获得锁
void unlock() 释放锁
代码示例

方法名	说明
ReentrantLock()	创建一个ReentrantLock的实例

方法名	说明
void lock()	获得锁
void unlock()	释放锁

 Lock lock = new ReentrantLock();
    //lock锁，使用时创建好对象后将synchronized(){方法体}替换为：
      lock.lock();
      //方法体
      lock.unlock();

4.4 死锁

简介

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
以下情况会产生死锁
1. 资源有限
2. 同步嵌套

5 线程池

2.1 概述

线程池可以看做成一个池子，在该池子中存储很多个线程。
线程池存在的意义：

系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

2.2 线程池的使用

线程池的使用一般可分为以下三步：

创建线程池
提交任务
销毁线程池(实际开发一般不会销毁)

示例代码：
自定义线程任务

public class MyTask implements Runnable{

    @Override
    public void run() {
        for (int i = 1; i <= 200; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

线程池

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //1.创建线程池
       // ExecutorService pool1 = Executors.newCachedThreadPool();//创建无上限的线程池
        ExecutorService pool1 = Executors.newFixedThreadPool(3);//创建有上限的线程池
        //2.提交任务
        pool1.submit(new MyTask());
        pool1.submit(new MyTask());
        pool1.submit(new MyTask());
        pool1.submit(new MyTask());
        pool1.submit(new MyTask());
        pool1.submit(new MyTask());
        //3.销毁线程池(实际开发一般不会销毁)
        //pool1.shutdown();

    }
}

2.3 自定义线程池

2.3.1 线程池的设计思路

准备一个任务容器
一次性启动多个(2个)消费者线程
刚开始任务容器是空的，所以线程都在wait
直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程。

2.2.2 创建自定义线程池

示例代码：

public class MyThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程数量，能小于0
                6,//最大线程数量，不能小于0，且要大于核心线程数量
                60,//空闲线程最大存活时间
                TimeUnit.SECONDS,//时间单位
                new ArrayBlockingQueue<>(3),//任务队列
                Executors.defaultThreadFactory(),//创建任务工厂
                new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略
        );

    }
}