目录
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内存模型的抽象示意如图所示。

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 | 终止状态,表示当前线程已经执行完毕 |

我们启动线程的时候用.start()和.run()的区别:
- start会新建线程
- 而run不会,只是简单的方法调用
线程间的通信
等待-通知机制

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 类的 set或get方法时才创建它们,实际上调用这两个方法的时候,我们调用的是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:任务满了之后,再来的任务会尝试去和最早的竞争,竞争不过就直接丢弃,也不抛出异常
本文深入探讨Java内存模型(JMM),阐述并发编程中的线程通信与同步问题。讲解线程的创建方式,包括继承Thread类、实现Runnable接口、Callable接口结合FutureTask、使用lambda表达式以及线程池。详细介绍了线程状态、等待-通知机制、ThreadLocal的使用以及线程池的工作原理和拒绝策略。线程池的使用降低了资源消耗,提高了响应速度和可管理性。

被折叠的 条评论
为什么被折叠?



