1.进程与线程的概念
（1）进程
程序有指令与数据组成，指令要运行，数据要读写，就必须指令加载到CPU。数据加载到内容，指令运行需要用到磁盘。
当一个程序被运行时，从磁盘加载这个程序的代码至内存，这时开启了一个进程。
（2）线程
一个进程之内可以分为一个或多个线程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。
Java中的 最小调度单位是线程，最小资源分配单位是进程。
2.并发与并行的概念
并发：同一时间应对多件事情的能力。
并行：同一时间动手做多件事情的能力。
3.异步与同步的概念
异步：不需要等待结果返回，就能继续运行
同步：需要等待结果返回，才能继续运行
同步在多线程中是让多个线程步调一致
4.多线程提高效率的结论
（1）单核CPU下，多线程不能实际提高程序运行效率，只是为了能够在不同任务之间切换，不同
线程轮流使用CPU，不至于一个线程总是占用一个CPU，别的线程没法干活。
（2）多核CPU下，可以并行运行多个线程，能否提高效率要分情况：
一些任务可以通过设计，将任务拆分，并行执行，可以提高运行效率。
不是所有任务都需要拆分，任务的目的不同。
（3）IO操作不占用CPU，只是我们一般拷贝文件使用的是 阻塞IO ，相当于线程虽然不用CPU，但是需要等待IO结束，没能充分利用线程，才有了 非阻塞IO 和 异步IO优化
5.创建线程
5.1 Thread的方式
Thread thread = new Thread(){
@Override
public void run(){
System.out.println("Hello JUC");
}
};
thread.start();
5.2 Runnable的方式
Runnable runnable = new Runnable(){
@Override
public void run(){
System.out.println("Hello JUC Runnable");
}
};
Thread thread = new Thread(runnable);
thread.start();
5.3 Lambda的方式
5.3.1 Thread的Lambda写法
Thread thread = new Thread(()->{ System.out.println("Hello JUC Lambda");});
thread.start();
5.3.2 Runnable的Lambda写法
Runnable runnable = ()->{
System.out.println("Hello JUC Lambda");
};
Thread thread = new Thread(runnable);
thread.start();
5.4 FutureTaks 配合 Thread
FutureTasks 能够接收Callable类型的参数，用于·处理有返回结果的情况
@Test
void testFutureTask() throws ExecutionException, InterruptedException {
FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("Running ...");
Thread.sleep(3000);
return 100;
}
});
Thread thread = new Thread(task);
thread.start();
System.out.println(task.get());
}
6.线程运行
线程运行现象：线程运行交替执行。谁先谁后，不由我们所控制。
查询线程的方式：
（1）windows：
可以通过任务管理器查看进程和线程数
tasklilst 查看进程
taskkill 杀死进程
（2）linux:
ps -fe 查看所有进程
ps -fT -p <PID> 这将显示PID进程及其所有线程的详细信息。
kill 杀死进程
top 按大写H切换是否显示线程
top -H -p <PID> 查看某个进程（PID）
（3）Java:
jps 命令查看所有Java进程
jstack <PID> 查看某个Java进程(PID)的所有线程状态
jconsole 来查看某个Java进程中线程的运行情况
7.线程运行的原理
7.1栈帧
JVM是由堆、栈、方法区所组成的，其中栈内存 存放就是线程，每个线程启动后，虚拟机就会分配一块栈内存。
每个栈有多个栈帧，对应着每次方法调用时所占用的内存。
每个线程只有一个活动栈帧，对应着当前正在执行的那个方法。
7.2上下文切换(Thread Context Switch)
可能因为
- 线程的cpu时间用完
- 垃圾回收
- 有更高优先级的线程需要运行
- 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法
当Thread Context Switch发送时，需要操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应的概念就是程序计数器，它的作用记录下一条jvm指令的执行地址，是线程私有的。
状态包括程序计数器，虚拟机中每个栈帧的信息，如局部变量，操作数栈，返回地址等
Thread Context Switch频繁发生会影响性能
8.线程中的常见方法
|------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 方法 | 描述 |
| start() | 启动新线程并执行该线程的run()方法。线程开始执行时，它的run()方法会被调用。 |
| run() | 当线程启动时，run()方法会被调用。这个方法应该包含线程的执行代码。 |
| join() | 等待调用join()方法的线程终止。例如，thread.join()会使当前线程等待thread线程终止。 |
| sleep(long millis) | 使当前线程暂停执行指定的毫秒数。线程不会失去任何监视器的所有权。 |
| interrupt() | 中断线程。如果线程在调用Object类的wait()、wait(long)、wait(long, int)、join()、join(long, int)或者sleep(long, int)方法时被阻塞，那么它的中断状态将被清除，并且它将接收到InterruptedException。 |
| isAlive() | 测试线程是否处于活动状态。如果线程已经启动且尚未终止，则线程处于活动状态。 |
| setName(String name) | 改变线程的名称，可以通过getName()方法获取线程的名称。 |
| getPriority() | 返回线程的优先级。线程的优先级可以设置为MIN_PRIORITY（1）、NORM_PRIORITY（5）或MAX_PRIORITY（10）。 |
| setPriority(int newPriority) | 变线程的优先级。线程优先级只是建议给调度器，实际调度可能会忽略它。 |
| yield() | 暂停当前正在执行的线程对象，并执行其他线程。 |
| getState() | 返回线程的状态。线程的状态可以是NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING或TERMINATED。 |
| isInterrupted() | 测试线程是否已经中断。不同于interrupted()方法，这个方法不会改变线程的中断状态。 |
8.1 run 与 start 的区别
（1）run() 方法：
run()方法是线程的执行主体，它包含了线程要执行的任务。- 当线程被启动时，
run()方法会被自动调用。 run()方法可以直接调用，就像调用普通方法一样，它在当前线程中执行，而不是在新线程中执行。- 如果直接调用
run()方法，程序不会创建新的线程，而是在当前线程中顺序执行run()方法中的代码。
（2）start() 方法：
start()方法用于启动一个新线程，并执行该线程的run()方法。- 当
start()方法被调用时，Java 虚拟机会创建一个新的线程，并执行run()方法中的代码。 start()方法只能被调用一次，多次调用会抛出IllegalThreadStateException。- 调用
start()方法后，线程可能会立即开始执行，也可能因为线程调度器的安排而在稍后执行。
8.2 Sleep和yield的区别
（3）Sleep
- 调用sleep让当前线程从Running进入Timed Waiting（阻塞）状态
- 其他线程可以通过interrupt方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException
- 睡眠解释后的线程未必会立即执行
- 建议使用Timeunit的sleep代替Thread的sleep，有更好的可读性
（4）yield
- 调用yield 会使当前线程从Running进入Runnable就绪状态，然后调度执行其他线程
- 具体的实现依赖操作系统的任务调度器
- 在Java中，
Thread.yield()也是一个静态方法，它使当前线程从运行状态转到可运行状态，但不会释放所占有的任何资源。 - 通常，
yield的使用并不频繁，因为它对线程调度提供的信息有限，且线程调度器可能会忽略这个提示。
8.3 线程优先级
- 线程优先级会提示调度器优先调度线程
- 如果CPU比较忙，那么优先级高的线程会获得更多的时间片；如果CPU比较空闲，优先级几乎没有什么作用。
8.4 Sleep实现
在没有利用CPU实现计算时，不要让while(true)空转浪费CPU，这时可以使用yield或sleep使CPU的使用权让给其他的程序
8.5 join实现
等待thread线程运行结束或终止。
如果join(long n)带参数的话，就是等待线程运行结束的最多等待n毫秒
8.6 打断阻塞
阻塞
打断sleep的线程，清空打断状态
示例：
@Test
void test() throws ExecutionException, InterruptedException {
Thread t1 = new Thread(()->{
try{
TimeUnit.SECONDS.sleep(12);
}catch (Exception e){
e.printStackTrace();
}
},"t1");
t1.start();
TimeUnit.SECONDS.sleep(2);
t1.interrupt();
System.out.println(t1.isInterrupted());
}
注意： 使用 isInterrupted()来判断是否打断成功，对于打断sleep 的结果为false则表示打断成功，同理wait和join 都是false标记为打断成功。
8.7 打断正常
打断正常的则isInterrupted()为true则表示打断成功
示例：
@Test
void test() throws InterruptedException {
Thread t1 = new Thread(()->{
try{
while (true){
boolean interrupted = Thread.currentThread().isInterrupted();
if (interrupted){
log.info("打斷...");
break;
}
}
}catch (Exception e){
e.printStackTrace();
}
},"t1");
t1.start();
TimeUnit.SECONDS.sleep(3);
log.info("interrupt");
t1.interrupt();
}
9.两阶段终止
问题：在一个线程T1中如何优雅的终止线程T2呢？
错误的思路：
- 使用stop方法终止线程，这种如果此时线程锁住了公共享资源，将其杀死后就再也没有机会释放资源，导致其他线程永远无法获取锁。
- 使用System.exit(int)方法停止线程，目的是仅停止一个线程，但是会让整个程序都停止
正确的思路：
@Test
void test() throws InterruptedException {
Thread t1 = new Thread(()->{
while (true){
Thread current = Thread.currentThread();
if(current.isInterrupted()){
log.info("打断....");
break;
}
try {
Thread.sleep(800);
log.info("正在记录中.....");
}catch (InterruptedException e){
e.printStackTrace();
//重置设置打断标识，因为sleep过程中进行interrupt是标识false,那么需要正常的interrupt使其标识为true
current.interrupt();
}
}
});
t1.start();
TimeUnit.SECONDS.sleep(3);
t1.interrupt();
}
10.打断park线程
打断线程后不会影响标记
11.不推荐的方法
这些方法过时，容易破坏同步代码块，造成线程死锁
|-----------|------------|
| 方法名 | 说明 |
| stop() | 停止线程运行 |
| suspend() | 挂起（暂停）线程运行 |
| resume() | 恢复线程运行 |
12.主线程与守护线程
默认情况下，Java进程需要等待线程运行都结束，才会结束。有一种特殊的线程是守护线程，只要其他的线程运行结束了，即使守护线程的代码还没有执行结束，也会强制结束。
示例：设置t1线程为守护线程：
t1.setDaemon(true);运用：
- 垃圾回收器线程就是一种守护线程
- 接收shutdown命令后，不会等待Acceptor和Poller守护线程处理完当前请求
13.线程的五种状态
五种状态：初始状态、可运行状态、运行状态、终止状态、阻塞状态
- 初始状态：仅在语言层面创建了线程对象，还未与操作系统线程关联
- 可运行状态；也称（就绪状态），指线程已经被创建（与操作系统线程未关联），可以由CPU调度执行
- 运行状态：指获取CPU时间片运行中的状态
- 阻塞状态：如果调用了阻塞API，这时线程实际不会用到CPU，会导致线程上下文切换，进入阻塞状态
- 终止状态：表示线程已经执行完毕，生命周期已经结束，不会转换为其他状态
14.共享资源的线程安全（synchronized）
竞态条件：发生在至少两个线程竞争同一资源时，而最终的结果取决于这些线程的执行顺序。在大多数情况下，竞态条件的出现是由于程序设计上的缺陷，例如没有适当的同步机制来控制对共享资源的访问。
为了避免临界的竞态的条件发生，可以使用以下的手段实现：
- 阻塞式的解决方案：Synchronized，Lock
- 非阻塞式的解决方案：原子变量
使用阻塞式的解决方案：Synchronized（对象锁），采用互斥的方式让同一时刻至多只有一个线程能持有 对象锁 ，其他线程再想获取这个 对象锁就会被阻塞住。这样可以保证线程可以安全的执行临界区内的代码，不用担心线程的上下文切换
- 互斥是保证临界区的竞态条件发生，同一时刻只有一个线程执行临界区代码
- 同步是由于线程执行的先后，顺序不同，需要一个线程等待其他线程运行到某个点
示例代码：
int counter = 0;
Object lock = new Object();
@Test
void test() throws InterruptedException {
Thread t1 = new Thread(()->{
for (int i = 0;i<=50000;i++){
synchronized(lock){
counter++;
}
}
});
Thread t2 = new Thread(()->{
for (int i = 0;i<=50000;i++){
synchronized(lock){
counter--;
}
}
});
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.info("Counter:{}",counter);
}
synchronized用对象锁保证了临界区内代码的原子性，临界区的代码对外不可分割，不会被线程切换所打断
思考：
如果synchronized(obj)放在for循环外面，如何理解？ --原子性
如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎么运行？--锁对象
如果 t1 synchronized(obj）而 t2没有加会怎么样？--锁对象
14.1 通过面向对象的方式实现：
创建实体：
public class Room {
private int counter = 0;
public void increment(){
synchronized (this){
counter++;
}
}
public void decrement(){
synchronized (this){
counter--;
}
}
public int getCounter(){
synchronized (this){
return counter;
}
}
}
实现代码：
Room room = new Room();
@Test
void test() throws InterruptedException {
Thread t1 = new Thread(()->{
room.increment();
});
Thread t2 = new Thread(()->{
room.decrement();
});
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.info("Counter:{}",room.getCounter());
}
14.2 synchronized加在方法上
（1）
public class Test {
public synchronized void test(){
}
}
相当于：
public class Test {
public void test(){
synchronized(this){
}
}
}
（2）static方法
public class Test {
public synchronized static void test(){
}
}
相当于：
public class Test {
public static void test(){
synchronized(Test.class){
}
}
}
15.变量线程安全分析
15.1 成员变量和静态变量是否线程安全？
（1）如果没有共享，则线程安全
（2）如果共享，根据他们的状态是否能够改变，分为两种情况：
- 如果只有读操作，则线程安全
- 如果有读写操作，则这段代码是临界区，需要考虑线程安全
15.2 局部变量是否线程安全？
（1）局部变量是线程安全的
（2）但是局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，则需要考虑线程安全
16.常用的线程安全类
- String
- Integer
- StringBuffer
- Random
- Vector
- Hashtable
- java.utils.concurrent包下的类
这里的线程安全是多线程调用它们同一个实例的某个方法时，线程是安全的。可以理解为
- 它们的每个方法是原子
- 但是它们的多个方法的组合不是原子的（不是线程安全的）
不可改变线程安全
String、Integer等都是不可变类，因为其内部的状态不可改变，因此它们的方法都是线程安全的
虽然String有replace、substring等方法可以改变值、但是根据源码可知都是创新一个新的对象，没有改变原有的对象的值，所以线程安全
17.买票问题习题
（1）线程安全问题示例
package org.example;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;
// 主类，用于执行售票模拟
public class ExerciseSell {
// 执行售票模拟的入口点
public static void main(String[] args) throws InterruptedException {
// 创建一个 TicketWindow 实例，初始票数为1000
TicketWindow ticket = new TicketWindow(1000);
// 创建一个线程列表，用于存放即将创建的线程
List<Thread> threadList = new ArrayList<>();
// 创建一个Integer类型的列表，用于存放每个线程卖出的票数
List<Integer> amountList = new Vector<>();
// 创建80000个线程，每个线程将模拟卖出一定数量的票
for(int i = 0; i < 80000; i++) {
Thread thread = new Thread(() -> {
// 每个线程卖出的票数是随机生成的
int amount = ticket.sell(randomAmount());
try {
// 模拟售票操作后的延迟
Thread.sleep(10);
} catch (InterruptedException e) {
// 如果线程在睡眠中被中断，抛出运行时异常
throw new RuntimeException(e);
}
// 将卖出的票数添加到amountList中
amountList.add(amount);
});
// 将新创建的线程添加到线程列表中
threadList.add(thread);
// 启动线程
thread.start();
}
// 等待所有线程完成
for (Thread thread : threadList) {
thread.join();
}
// 打印剩余票数
System.out.println("余票：" + ticket.getAmount());
// 计算所有线程卖出的票数总和并打印
System.out.println("卖出的票数：" + amountList.stream().mapToInt(i -> i).sum());
}
// 生成随机售票数的方法
static Random random = new Random();
public static int randomAmount() {
// 返回1到5之间的随机整数，包括1和5
return random.nextInt(5) + 1;
}
}
// 表示售票窗口的类
class TicketWindow {
// 私有属性，表示售票窗口的票数
private int amount;
// 构造函数，初始化票数为传入的参数
public TicketWindow(int amount) {
this.amount = amount;
}
// 获取当前票数的方法
public int getAmount() {
return amount;
}
// 售票方法，尝试从窗口卖出指定数量的票
public int sell(int amount) {
if (this.amount >= amount) {
// 如果票数足够，减少票数并返回卖出的票数
this.amount -= amount;
return amount;
} else {
// 如果票数不足，返回0
return 0;
}
}
}
（2）解决线程安全问题方法
这段代码存在线程安全问题。具体来说，TicketWindow 类的 amount 成员变量在被多个线程访问和修改时，没有使用任何同步机制，这可能导致多个线程同时修改 amount，从而引发数据不一致的问题。
所以要给amount 进行共享资源读写的时进行加锁操作（这段代码，只需要对sell方法加上synchronized即可加锁）
public synchronized int sell(int amount){
if(this.amount >= amount){
this.amount -= amount;
return amount;
}else {
return 0;
}
}
18. 转账习题
（1）线程安全问题示例
package org.example;
import java.util.Random;
public class ExerciseTransfer {
public static void main(String[] args) throws InterruptedException {
Amount a = new Amount(1000);
Amount b = new Amount(1000);
Thread t1 = new Thread(()->{
for(int i = 0;i < 100;i++){
a.transfer(b,randomAmount());
}
});
Thread t2 = new Thread(()->{
for(int i = 0;i < 100;i++){
b.transfer(a,randomAmount());
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("总金额："+a.getMoney() + b.getMoney());
}
static Random random = new Random();
public static int randomAmount(){
return random.nextInt(100) + 1;
}
}
class Amount{
private int money;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public Amount(int money) {
this.money = money;
}
public void transfer(Amount amount,int transferMoney){
if(this.money >= transferMoney){
this.setMoney(this.getMoney() - transferMoney);
amount.setMoney(amount.getMoney() + transferMoney);
}
}
}
（2）解决线程安全问题方法（两个共享变量）
public void transfer(Amount amount,int transferMoney){
synchronized(Amount.class){
if(this.money >= transferMoney){
this.setMoney(this.getMoney() - transferMoney);
amount.setMoney(amount.getMoney() + transferMoney);
}
}
}
因为如果
public synchronized void transfer(Amount amount,int transferMoney){
if(this.money >= transferMoney){
this.setMoney(this.getMoney() - transferMoney);
amount.setMoney(amount.getMoney() + transferMoney);
}
}
相当于保护this.money，但是不保护amount的money
public void transfer(Amount amount,int transferMoney){
synchronized(this){
if(this.money >= transferMoney){
this.setMoney(this.getMoney() - transferMoney);
amount.setMoney(amount.getMoney() + transferMoney);
}
}
}