一、线程基础知识
1 进程与线程
进程： 操作系统会议进程为单位，分配系统资源（CPU时间片、内存等资源），进程是资源分配的最小单位。
线程： 线程是进程中的实体，一个进程可拥有多个线程，一个线程必须有一个父进程，线程是CPU调度的最小单位。
从图中可以看出线程是进程一个子集，线程存在于进程内，而进程是相互独立的。进程拥有共享的内存空间，供内部线程共享。线程是更加轻量的，切换成本要比进程上下文切换低。
2 并发与并行
并发： 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行。
并行： 指应用能够同时执行不同的任务，比如边吃饭边看电视。
他们两并发是交替执行，并行是同时执行。
2.1 高并发的好处
（1）充分利用CPU资源
（2）加快响应用户时间
（3）可是代码模块化、异步化、简单化。
2.2 多线程程序注意事项
（1）线程之间的安全性：在同一个进程里面的多线程是资源共享的,也就 是都可以访问同一个内存地址当中的一个变量。若有多 个线程同时执行写操作,一般都需要考虑线程同步,否则就可能影响线程安全。
（2）线程之间的死锁：多线程之间相互持有锁而不能释放，就会导致程序无法继续运行，因此引入了Java锁机制。
（3）线程太多会将CPU资源耗尽而死机：线程数太多有可能造成系统创建大量线程而导致消耗完系统内存以及 CPU 的“过渡切换”,造成系统的死机。可根据服务器配置使用线程池，配置合适的多线程参数。
2.3上下文切换
上下文切换是指CPU(中央处理单元)从一个进程或线程到另一个进程或线程的切换。
上下文切换可以更详细地描述为内核(即操作系统的核心)对CPU上的进程(包括线程)执行以下活动:
- 暂停一个进程的处理，并将该进程的CPU状态(即上下文)存储在内存中的某个地方
- 从内存中获取下一个进程的上下文，并在CPU的寄存器中恢复它
- 返回到程序计数器指示的位置(即返回到进程被中断的代码行)以恢复进程。
上下文切换只能在内核模式下发生。 内核模式是CPU的特权模式，其中只有内核运行，并提供对所有内存位置和所有其他系统资源的访问。其他程序(包括应用程序)最初在用户模式下运行，但它们可以通过系统调用运行部分内核代码。
上下文切换是多任务操作系统的一个基本特性。 在多任务操作系统中，多个进程似乎同时在一个 CPU上执行，彼此之间互不干扰。这种并发的错觉是通过快速连续发生的上下文切换(每秒数十次 或数百次)来实现的。这些上下文切换发生的原因是进程自愿放弃它们在CPU中的时间，或者是调度器在进程耗尽其CPU时间片时进行切换的结果。
上下文切换通常是计算密集型的。 就CPU时间而言，上下文切换对系统来说是一个巨大的成本， 实际上，它可能是操作系统上成本最高的操作。因此，操作系统设计中的一个主要焦点是尽可能地避免不必要的上下文切换。与其他操作系统(包括一些其他类unix系统)相比，Linux的众多优势之一是它的上下文切换和模式切换成本极低。
造成CPU上下文切换的操作：
- 线程、进程切换
- 系统调用
- 中断
2.4 操作系统层面线程的生命周期
在操作系统层面，线程可分为五态：初始状态、可运行状态、运行状态、休眠状态、终止状态。
- 初始状态： 指的是线程已经被创建，但是还不允许分配 CPU 执行。这个状态属于编程 语言特有的，不过这里所谓的被创建，仅仅是在编程语言层面被创建，而在操作系统层 面，真正的线程还没有创建。
- 可运行状态： 指的是线程可以分配 CPU 执行。在这种状态下，真正的操作系统线程已 经被成功创建了，所以可以分配 CPU 执行。
- 运行状态： 当有空闲的 CPU 时，操作系统会将其分配给一个处于可运行状态的线程，被分配到 CPU 的线程的状态就转换成了运行状态。
- 休眠状态： 运行状态的线程如果调用一个阻塞的 API（例如以阻塞方式读文件）或者等待某个事件 （例如条件变量），那么线程的状态就会转换到休眠状态，同时释放 CPU 使用权，休眠 状态的线程永远没有机会获得 CPU 使用权。当等待的事件出现了，线程就会从休眠状态 转换到可运行状态。
- 终止状态： 线程执行完或者出现异常就会进入终止状态，终止状态的线程不会切换到其他任何状 态，进入终止状态也就意味着线程的生命周期结束了。
2.5 Java线程的生命周期
Java语言中线程共有六种状态，为：
- NEW：初始化状态。
- RUNNABLE：可运行线程的线程状态，处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
- BLOCKED：等待监视器锁而阻塞的线程的线程状态，处于阻塞状态的线程正在等待监视器锁进入同步块方法或在调用Object.wait后重新进入同步块方法。
- WAITING：等待线程的线程状态，处于等待状态的线程正在等待另一个线程执行特定的操作。例如，在对象上调用object. wait()的线程正在等待另一个线程在该对象上调用object. notify()或object. notifyall()。调用thread .join()的线程正在等待指定的线程终止。
- TIMED_WAITING：具有指定等待时间的等待线程的线程状态。线程处于定时等待状态的原因是调用了方法中的一个并指定了正等待时间:
- Thread.sleep
- Object.wait with timeout
- Thread.join with timeout
- LockSupport.parkNanos
- LockSupport.parkUntil
- TERMINATED：已终止线程的线程状态。线程已完成执行。
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system
* such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock
* to enter a synchronized block/method or
* reenter a synchronized block/method after calling
* {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
二、Java线程详解
1 线程的实现方式
1.1 使用或继承Thread类
//1.继承Thread类
Thread t = new Thread() {
@Override
public void run() {
System.out.println("创建 Thread 线程");
}
};
t.start();
1.2 实现Runable接口
//2.实现 Runnable 接口
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("创建 Runnable 线程");
}
};
new Thread(r).start();
1.3 使用有返回值的 Callable
//3.实现Callable
Callable<Integer> c = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("创建 Callable 线程");
return 0;
}
};
ExecutorService service = Executors.newFixedThreadPool(5);
Future<Integer> result = service.submit(c);
1.4 使用 lambda
new Thread(() -> {
System.out.println("创建 lambda 线程");
}).start();
本质上Java中实现线程只有一种方式，都是通过new Thread()创建线程，调用Thread#start启 动线程最终都会调用Thread#run方法
2 Java线程实现原理
Java线程执行为什么不能直接调用run()方法,而要调用start()方法？
由图分析可知直接调用run方法走的是Java方法调用，并不会启动操作系统线程，只有调用start方法时，才会调用native方法启动系统线程。
线程创建和启动的流程总结：
- 使用 new Thread() 创建一个线程，然后调用start()方法进行java层面的线程启动。
- 调用本地方法 start0()，去调用jvm中的 JVM_StartThread() 方法进行线程创建和启动。
- 调用 new JavaThread(&thread_entry, sz) 进行线程的创建，并根据不同的操作系统平台调用对应的 os::create_thread 方法进行线程创建。
- 新创建的线程状态为 Initialized，地哦啊用了额 sync->wait() 的方法进行等待，等到被唤醒才继续执行 thread->run()。
- 调用 Threaed::start(native_thread) 方法进行线程的启动，此时线程状态设置为RUNNABLE， 接着调用 os::start_thread(thread)， 根据不同的操作系统选择不同的线程启动方式。
- 线程启动之后状态设置为 RUNNABLE，并唤醒第4步中等待的线程，接着执行 thread->run() 方法。
- JavaThread::run() 方法会回调第1步 new Thread 中复写的 run() 方法。
3 并发的三大特性
- 可见性： 当一个线程修改了共享变量的值，其他线程能够看到修改的值。
- 有序性： 程序执行的顺序按照代码的先后顺序执行。
- 原子性： 一个或多个操作，要么全部执行，要么全部不执行，在执行过程中不被任何因素打断。
可见性保证：
- 通过 volatile 关键字保证可见性。
- 通过 内存屏障保证可见性。
- 通过 synchronized 关键字保证可见性。
- 通过 Lock保证可见性。
- 通过 final 关键字保证可见性
有序性保证：
- 通过 volatile 关键字保证可见性。
- 通过 内存屏障保证可见性。
- 通过 synchronized关键字保证有序性。
- 通过 Lock保证有序性。
原子性保证：
- 通过 synchronized 关键字保证原子性。
- 通过 Lock保证原子性。
- 通过 CAS保证原子性。
4 JMM内存模型
JMM定义：Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），用于屏蔽掉各 种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果。
代码示例：
package com.sonny.classexercise.concurrent;
import org.springframework.objenesis.instantiator.sun.UnsafeFactoryInstantiator;
import java.util.concurrent.locks.LockSupport;
/**
* 多线程可见性测试
*
* @author Xionghaijun
* @date 2022/10/24 22:00
*/
public class VisibilityTest {
private volatile boolean flag = true;
private int i = 0;
private void refresh() {
flag = false;
System.out.println(Thread.currentThread().getName() + "修改flag");
}
private void load() {
System.out.println(Thread.currentThread().getName() + "开始执行......");
while (flag) {
//执行业务逻辑
i++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println(Thread.currentThread().getName() + "跳出循环： i = " + i);
}
public static void main(String[] args) throws InterruptedException {
VisibilityTest visibilityTest = new VisibilityTest();
new Thread(() -> visibilityTest.load(), "thread_A").start();
Thread.sleep(1000);
new Thread(() -> visibilityTest.refresh(), "thread_b").start();
}
}
4.1 JMM内存交互操作
主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、 如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：
- lock（锁定）： 作用于主内存的变量，把一个变量标识为一条线程独占状态。
- unlock（解锁）： 作用于主内存变量，把一个处于锁定状态的变量释放出来，释放 后的变量才可以被其他线程锁定。
- read（读取）： 作用于主内存变量，把一个变量值从主内存传输到线程的工作内存 中，以便随后的load动作使用 。
- load（载入）： 作用于工作内存的变量，它把read操作从主内存中得到的变量值放 入工作内存的变量副本中。
- use（使用）： 作用于工作内存的变量，把工作内存中的一个变量值传递给执行引 擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
- assign（赋值）： 作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给 工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
- store（存储）： 作用于工作内存的变量，把工作内存中的一个变量的值传送到主 内存中，以便随后的write的操作。
- write（写入）： 作用于主内存的变量，它把store操作从工作内存中一个变量的值 传送到主内存的变量中。
Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
- 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。 但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
- 不允许read和load、store和write操作之一单独出现 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须 同步到主内存中。
- 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回 主内存中。
- 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化 （load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过 了assign和load操作。
- 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条 线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解 锁。lock和unlock必须成对出现。
- 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用 这个变量前需要重新执行load或assign操作初始化变量的值。
- 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许 去unlock一个被其他线程锁定的变量。
- 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和 write操作）。
4.2 Volatile的内存语义
volatile的特性
可见性： 对一个volatile变量的读，总是能看到对这个变量最后的写入。
有序性： 对volatile修饰的变量的读写操作会在前后加上各种特定的内存屏障来禁止指令的重排序。
原子性： 仅保证单个volatile变量的读/写具有原子性（volatile修饰的long、double）。
volatile读-写内存语义
- 当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到 主内存。
- 当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效，线程接下来 将从主内存中读取共享变量。
volatile可见性实现原理
JMM内存交互层面实现： volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修 改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量操作对多线程 的可见性。
硬件层面实现： 通过lock前缀指令，会锁定变量缓存行区域并写回主内存，这个操作称为“缓存锁定”， 缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。一个处理器的缓存回 写到内存会导致其他处理器的缓存无效。
JVM层面的内存屏障
在JSR规范中定义了4种内存屏障：
LoadLoad屏障：（指令Load1; LoadLoad; Load2），在Load2及后续读取操作要读取的数 据被访问前，保证Load1要读取的数据被读取完毕。
LoadStore屏障：（指令Load1; LoadStore; Store2），在Store2及后续写入操作被刷出前， 保证Load1要读取的数据被读取完毕。 StoreStore屏障：（指令Store1; StoreStore; Store2），在Store2及后续写入操作执行前， 保证Store1的写入操作对其它处理器可见。 StoreLoad屏障：（指令Store1; StoreLoad; Load2），在Load2及后续所有读取操作执行 前，保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的。在大多数处理器的 实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的功能。
由于x86只有store load可能会重排序，所以只有JSR的StoreLoad屏障对应它的mfence或 lock前缀指令，其他屏障对应空操作
硬件层内存屏障
硬件层提供了一系列的内存屏障 memory barrier / memory fence(Intel的提法)来提供 一致性的能力。拿X86平台来说，有几种主要的内存屏障：
- lfence，是一种Load Barrier 读屏障
- sfence, 是一种Store Barrier 写屏障
- mfence, 是一种全能型的屏障，具备lfence和sfence的能力
- Lock前缀，Lock不是一种内存屏障，但是它能完成类似内存屏障的功能。Lock会对 CPU总线和高速缓存加锁，可以理解为CPU指令级的一种锁。
内存屏障有两个能力：
- 阻止屏障两边的指令重排序。
-
- 刷新处理器缓存/冲刷处理器缓存。
扫一扫
1291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
