Java并发编程(三)之并发编程基础——多线程、线程池详解

本文深入探讨Java内存模型(JMM),阐述并发编程中的线程通信与同步问题。讲解线程的创建方式,包括继承Thread类、实现Runnable接口、Callable接口结合FutureTask、使用lambda表达式以及线程池。详细介绍了线程状态、等待-通知机制、ThreadLocal的使用以及线程池的工作原理和拒绝策略。线程池的使用降低了资源消耗,提高了响应速度和可管理性。

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


Java内存模型(JMM)

并发编程模型的两个关键问题

在并发编程中,需要处理两个关键问题:线程之间如何通信及线程之间如何同步(这里的线程是指并发执行的活动实体)。通信是指线程之间以何种机制来交换信息。在命令式编程中,线程之间的通信机制有两种:共享内存和消息传递。(Java中并发采用共享内存模型)

共享内存的并发模型里,线程之间共享程序的公共状态,通过写-读内存中的公共状态进行隐式通信。
消息传递的并发模型里,线程之间没有公共状态,线程之间必须通过发送消息来显式进行通信。

Java内存模型的抽象结构

在Java中,所有实例域、静态域和数组元素都存储在堆内存中,堆内存在线程之间共享。局部变量(Local Variables),方法定义参数(Java语言规范称之为Formal Method Parameters)和异常处理器参数(Exception Handler Parameters)不会在线程之间共享,它们不会有内存可见性问题,也不受内存模型的影响。

Java线程之间的通信由Java内存模型(简称为JMM)控制,JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看,JMM定义了线程和主内存之间的抽象关系:线程之间的共享变量存储在主内存(Main Memory)中,每个线程都有一个私有的本地内存(Local Memory),本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意如图所示。

image-20220623161241483

JMM通过控制主内存与每个线程的本地内存之间的交互,来为Java程序员提供内存可见性保证。


线程

什么是线程

现代操作系统在运行一个程序时,会为其创建一个进程。例如,启动一个Java程序,操作系统就会创建一个Java进程。现代操作系统调度的最小单元是线程,也叫轻量级进程(Light Weight Process),在一个进程里可以创建多个线程,这些线程都拥有各自的计数器、堆栈和局部变量等属性,并且能够访问共享的内存变量。处理器在这些线程上高速切换,让使用者感觉到这些线程在同时执行。 一个Java程序从main()方法开始执行,然后按照既定的代码逻辑执行,看似没有其他线程参与,但实际上Java程序天生就是多线程程序,因为执行main()方法的是一个名称为main的线程。

我们在开始详细了解线程之前我们需要知道为什么要使用多线程?
1.更多的处理器核心
2.更快的响应时间
3.更好的编程模型

创建线程的几种方式

1.继承Thread类

public class MyThread01 extends Thread{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName() + "正在运行");
    }

    public static void main(String[] args) {
       MyThread01 myThread01 = new MyThread01();
        myThread01.start();
   		System.out.println(Thread.currentThread().getName() + "正在运行");
    }
}

2.实现Runnable接口

需要注意的是,当使用实现Runnable接口的方式创建的线程在线程启动的时候不能直接用实现Runnable接口的实现类调start()方法,而是要当做参数传入Thread类实例,然后调用start()方法进行线程启动,原因就是下面这个Runnable接口的实现类MyThread02 不是线程类。

public class MyThread02 implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName() + "正在运行");
    }

    public static void main(String[] args) {
        MyThread02 myThread02 = new MyThread02();
        Thread thread = new Thread(myThread02);
        thread.start();
        System.out.println(Thread.currentThread().getName() + "正在运行");
    }
}

tips:其实我们的第一种方式中继承的Thread类在源码中也是实现了Runnable接口

3.实现Callable接口结合FutureTask

这种创建线程的方式在实际工作中不用常用,FutureTask是一个实现Runnable接口的类,FutureTask内部有一个成员变量将callable接口的返回值保存起来,并通过提供get方法获取。

public class MyThread03 implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "正在运行");
        return "call() 执行完毕";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyThread03());
        Thread thread3 = new Thread(futureTask);
        thread3.start();
        System.out.println(Thread.currentThread().getName() + futureTask.get());
    }
}

4.使用lambda表达式

public class MyThread04 {
    public static void main(String[] args) {
        Thread thread = new Thread(() ->{
            System.out.println(Thread.currentThread().getName() + "正在运行");
        });
        thread.start();
    }
}

也可以简写为:

public class MyThread04 {
    public static void main(String[] args) {
        new Thread(() ->{
            System.out.println(Thread.currentThread().getName() + "正在运行");
        }).start();
    }
}

5.使用线程池

这种方式其实是实际工作中使用的最多的一种方式,也是最容易被大家遗忘的,有关线程池的部分在这篇文章的末尾会提到。


线程的状态

状态名称说明
NEW初始状态,线程被构建,但是还没有调用start()方法
RUNNABLE运行状态,Java线程将操作系统中的就绪和运行两种状态笼统地称作“运行中”
BLOCKED阻塞状态,表示线程阻塞于锁
WAITING等待状态,表示线程进入等待状态,进入该状态表示当前线程需要等待其他线程做出一些特定动作(通知或中断)
TIME_WAITING超时等待状态,该状态不同于WAITING,他是可以在指定的时间自行返回的
TERMINATED终止状态,表示当前线程已经执行完毕

image-20220624150940416

我们启动线程的时候用.start()和.run()的区别:

  • start会新建线程
  • 而run不会,只是简单的方法调用

线程间的通信

等待-通知机制

image-20220624165927696

WaitThread首先获取了对象的锁,然后调用对象的wait()方法,从而放弃了锁并进入了对象的等待队列WaitQueue中,进入等待状态。由于WaitThread释放了对象的锁,NotifyThread随后获取了对象的锁,并调用对象的notify()方法,将WaitThread从WaitQueue移到SynchronizedQueue中,此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后,WaitThread再次获取到锁并从wait()方法返回继续执行。

等待-通知经典范式

等待方遵循如下原则:

  • 获取对象的锁
  • 如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件
  • 条件满足则执行对应的逻辑
synchronized(对象) { 
	while(条件不满足) { 
		对象.wait(); 
	}
	对应的处理逻辑 
}

通知方遵循如下原则:

  • 获得对象的锁
  • 改变条件
  • 通知所有等待在对象上的线程
synchronized(对象) { 
	改变条件 
	对象.notifyAll(); 
}

在等待-通知中为什么用while而不用if?

就是用 if 判断的话,唤醒后线程会从 wait 之后的代码开始运行,但是不会重新判断 if 条件,直接继续运行 if 代码块之后的代码,而如果使用 while 的话,也会从 wait 之后的代码运行,但是唤醒后会重新判断循环条件,如果不成立再执行 while 代码块之后的代码块,成立的话继续 wait。

Thread.join()的使用

如果一个线程A执行了thread.join()语句,其含义是:当前线程A等待thread线程终止之后才从thread.join()返回。

ThreadLocal()的使用

ThreadLocal,即线程变量,是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

通常情况下,我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢? JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值,可以将ThreadLocal类形象的比喻成存放数据的盒子,盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量,那么访问这个变量的每个线程都会有这个变量的本地副本,这也是ThreadLocal变量名的由来。他们可以使用 get()set() 方法来获取默认值或将其值更改为当前线程所存的副本的值,从而避免了线程安全问题。

原理:

public class Thread implements Runnable {
 ......
//与此线程有关的ThreadLocal值。由ThreadLocal类维护
ThreadLocal.ThreadLocalMap threadLocals = null;

//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
 ......
}

从上面Thread类 源代码可以看出Thread 类中有一个 threadLocals 和 一个 inheritableThreadLocals 变量,它们都是 ThreadLocalMap 类型的变量,我们可以把 ThreadLocalMap 理解为ThreadLocal 类实现的定制化的 HashMap。默认情况下这两个变量都是null,只有当前线程调用 ThreadLocal 类的 setget方法时才创建它们,实际上调用这两个方法的时候,我们调用的是ThreadLocalMap类对应的 get()set() 方法。

ThreadLocal类的set()方法

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

通过上面这些内容,我们足以通过猜测得出结论:最终的变量是放在了当前线程的 ThreadLocalMap 中,并不是存在 ThreadLocal 上,ThreadLocal 可以理解为只是ThreadLocalMap的封装,传递了变量值。

每个Thread中都具备一个ThreadLocalMap,而ThreadLocalMap可以存储以ThreadLocal为key的键值对。 比如我们在同一个线程中声明了两个 ThreadLocal 对象的话,会使用 Thread内部都是使用仅有那个ThreadLocalMap 存放数据的,ThreadLocalMap的 key 就是 ThreadLocal对象,value 就是 ThreadLocal 对象调用set方法设置的值。ThreadLocal 是 map结构是为了让每个线程可以关联多个 ThreadLocal变量。这也就解释了ThreadLocal声明的变量为什么在每一个线程都有自己的专属本地变量。

线程池

为什么要用线程池?

池化技术相比大家已经屡见不鲜了,线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗,提高对资源的利用率。

线程池提供了一种限制和管理资源(包括执行一个任务)。 每个线程池还维护一些基本统计信息,例如已完成任务的数量。

  • 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  • 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
  • 提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。

如何使用线程池?

一般是通过 ThreadPoolExecutor 的构造函数来创建线程池,然后提交任务给线程池执行就可以了。
具体使用如下:

public class ThreadPoolTest {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final int KEEP_ALIVE_TIME = 5;

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        for (int i = 0 ; i < 10 ; i++){
            executor.execute(()->{
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("CurrentThread name:" + Thread.currentThread().getName() + "data:" + Instant.now());
            });
        }

        executor.shutdown();
        try {
            executor.awaitTermination(5,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Finished all threads");
    }
}

线程池的七大参数及名词解释

1、corePoolSize: 核心线程数
2、maximumPoolSize: 最大线程数
3、keepAliveTime: 最大空闲时间
4、TimeUnit unit: 时间单位
5、BlockingQueue workQueue: 阻塞队列
6、ThreadFactory threadFactory: 线程工厂
7、RejectedExecutionHandler handler: 拒绝策略

当我们向线程池提交一个任务会发生什么?

在这里插入图片描述

  • 当我们有一个任务提交给线程池去执行的时候,线程池会先判断是否有空闲的核心线程,如果有,则让核心线程执行这个任务,如果没有,则会加入到阻塞队列当中
  • 当阻塞队列里面也放满了任务之后,会创建非核心线程去执行新增的任务(不是从阻塞队列里面取,而是新来的任务)
  • 如果核心线程与非核心线程的数量达到了最大线程数,也就是此时已经没有了任何空闲的线程,阻塞队列里面也放满的话,线程池就会执行拒绝策略,拒绝任务

线程池中的拒绝策略是什么?

1、AbortPolicy(线程池默认):如果线程池中没有空闲线程且达到了最大数,阻塞队列满了,此时再来任务的话会直接抛出异常
2、CallerRunsPolicy:哪个线程交给线程池这个任务就会让哪个线程自己去执行这个任务
3、DiscardPolicy:任务满了之后,会直接丢掉任务,并且不抛出异常
4、DiscardOldestPolicy:任务满了之后,再来的任务会尝试去和最早的竞争,竞争不过就直接丢弃,也不抛出异常

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值