目录
[1. 线程与进程](#1. 线程与进程)
[2. 并发和并行](#2. 并发和并行)
[3. CPU 调度](#3. CPU 调度)
[Lock 接口的主要方法](#Lock 接口的主要方法)
[Lock 接口的实现类](#Lock 接口的实现类)
[使用Condition 对象](#使用Condition 对象)
1. 线程与进程
进程（Process）
-
定义：进程是操作系统进行资源分配和调度的基本单位。每个进程都有自己独立的虚拟地址空间、系统资源（如文件句柄、内存等）和一组系统状态信息。
-
特点：
-
独立性：每个进程都有自己的独立内存空间，不会直接影响其他进程。
-
资源分配：进程拥有独立的系统资源，如文件描述符、内存等。
-
生命周期：进程从创建到终止有一个完整的生命周期，包括创建、就绪、运行、阻塞和终止等状态。
-
线程（Thread）
-
定义：线程是进程内的一个执行单元，是操作系统进行调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，但每个线程有自己的栈和程序计数器。
-
特点：
-
轻量级：相比于进程，线程的创建和切换开销较小。
-
资源共享：同一进程内的线程共享进程的内存和其他资源。
-
并发执行：多个线程可以并发执行，提高程序的响应性和资源利用率。
-
2. 并发和并行
并发（Concurrency）
-
定义：并发是指多个任务在同一时间段内交错执行，但不一定同时执行。操作系统通过时间片调度在多个任务之间快速切换，使这些任务看起来像是同时执行的。
-
特点：
-
时间片调度：操作系统为每个任务分配一个时间片，在这段时间内任务可以执行。
-
上下文切换：任务之间通过上下文切换来交替执行。
-
适用场景：适用于 I/O 密集型任务，如网络请求、文件读写等。
-
并行（Parallelism）
-
定义：并行是指多个任务在同一时刻真正同时执行。这通常需要多核处理器的支持，每个核心可以同时执行一个任务。
-
特点：
-
多核处理器：并行计算依赖于多核处理器，每个核心可以独立执行任务。
-
提高计算效率：并行计算可以显著提高计算密集型任务的执行效率。
-
适用场景：适用于计算密集型任务，如矩阵运算、图像处理等。
-
3. CPU 调度
定义
- CPU 调度：CPU 调度是操作系统的核心功能之一，负责在多个进程或线程之间分配 CPU 时间。调度器根据一定的算法选择下一个执行的进程或线程，确保系统的高效运行。
类型
-
长期调度（Job Scheduler）：负责决定哪些进程可以进入内存并准备执行。通常在进程创建时进行。
-
中期调度（Swapper）：负责在内存和磁盘之间交换进程，以释放内存空间。
-
短期调度（CPU Scheduler）：负责在就绪队列中的进程或线程之间分配 CPU 时间。是最常见和最重要的调度类型。
调度算法
-
先来先服务（First-Come, First-Served, FCFS）：按照进程到达的顺序进行调度。
-
短作业优先（Shortest Job Next, SJN）：优先调度预计运行时间最短的进程。
-
优先级调度（Priority Scheduling）：根据进程的优先级进行调度，优先级高的进程优先执行。
-
轮转法（Round Robin, RR）：每个进程或线程分配一个固定的时间片，时间片结束后切换到下一个进程或线程。
-
多级反馈队列（Multilevel Feedback Queue）：结合多种调度策略，根据进程的行为动态调整其优先级和时间片。
上下文切换
-
定义：上下文切换是指从一个进程或线程切换到另一个进程或线程的过程。包括保存当前进程或线程的状态，加载下一个进程或线程的状态。
-
开销：上下文切换会消耗 CPU 时间和内存资源，频繁的上下文切换会影响系统的整体性能。
4.线程间的状态流转
线程的主要状态
-
NEW：线程被创建但是未启动
-
RUNNABLE：线程正在运行或者准备运行
-
BLOCKED：线程被阻塞，等待锁进入同步块或方法
-
WAITING ：线程无限等待，需要其他线程调用特定方法唤醒
-
TIMED_WAITING：线程有限等待，指定时间过后恢复或被其他线程唤醒
-
TERMINATED：线程终止，执行完毕或者异常停止
注意：
-
sleep(time)和wait(time)的区别：
-
sleep(time)线程睡眠，睡眠的过程不会释放锁。到时间后自动醒来继续执行。
-
wait(time)线程等待，等待的过程会释放锁，其他线程可以抢，等待过程中被唤醒或者到时间后会进入队列争抢锁。
-
-
wait()和notify()：
-
wait()无限等待，会释放锁，需要其他线程调用notify()或则notifyAll()唤醒，被唤醒后进入队列争抢锁
-
notify()一次只能唤醒一条等待的线程，如果是多条线程等待中，随机 唤醒一条等待中的线程。
-
notifyAll()唤醒所有等待中的线程。
-
notify()和notifyAll()都不会影响sleep状态的线程
-
-
wait()和notify()的共同点
-
都需要锁对象，所以在同步方法或者块中执行
-
两个方法的调用必须是同一个锁对象调用：理解为同一个锁对象将多条线程分到了一组中，notify就知道唤醒的是本组(同一个同步方法或块)的等待线程
-
5.创建线程的方法
线程的创建方法总共可以分为5种。
-
继承Thread类，通过重写run()方法创建线程
public class ThreadOne extends Thread { public void run() { System.out.println("Thread One is running"); } public static void main(String[] args) { ThreadOne threadOne = new ThreadOne(); //调用start方法,开启线程,jvm自动调用run方法 threadOne.start(); } }Thread类中的方法：
-
void start()：开启线程，jvm自动调用run()方法
-
void run()：设置线程任务。Thread重写Runnable中的run()方法
-
String getName()：获取线程名字
-
void setName()：给线程设置名字
-
static Thread currentThread()：获取当前线程对象
-
static void sleep(long millis)：线程睡眠，超时后自动醒来继续执行，参数是毫秒
-
void setpriority(int newPriority)：设置线程优先级
-
void join() 插队
-
void yield() 礼让
-
-
实现Runnable接口，实现run()方法创建线程
public class ThreadTwo implements Runnable{ @Override public void run() { System.out.println("Thread Two is running"); } public static void main(String[] args) { ThreadTwo threadTwo = new ThreadTwo(); /* Thread(Runnable target) */ Thread thread = new Thread(threadTwo); thread.start(); } } -
使用Lambda表达式匿名内部类，简化Runnale的创建
public class ThreadThree { public static void main(String[] args) { new Thread(new Runnable(){ @Override public void run() { System.out.println("Thread Three is running"); } },"threadThree").start(); } } -
使用ExecutorService创建和管理线城池，使用线程池创建
使用
ExecutorService创建线程池时，newFixedThreadPool和newCachedThreadPool是两种常用的工厂方法。然而，这两种线程池在某些情况下可能会因为资源耗尽而导致OutOfMemoryError（OOM）。注意：实际的开发中不要使用ExecutorService创建线程池，要使用new ThreadPoolExecutor的方式。
public static void main(String[] args) { // 线程池参数 int corePoolSize = 5; // 核心线程数 int maximumPoolSize = 10; // 最大线程数 long keepAliveTime = 60L; // 线程空闲时间 TimeUnit unit = TimeUnit.SECONDS; // 时间单位 BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100); // 工作队列 ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 线程工厂 RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy(); // 拒绝策略 // 创建线程池 ThreadPoolExecutor executor = new ThreadPoolExecutor( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler ); // 提交大量任务省略... // 关闭线程池 executor.shutdown(); }-
newFixedThreadPool使用的是无界队列，当队列中的任务增长速度远大于处理的速度，队列会不断增长，导致内存耗尽。应对思路：设置有限队列存放任务
-
newCachedThreadPool使用的是可缓存的线程池，当任务的提交速度大于处理速度，线程池不断创建新线程，导致内存耗尽。应对思路：设置拒绝策略。
-
-
使用FutureTask和Callable创建
FutureTask和Callable是用于实现异步计算和返回结果的重要接口和类。public class ThreadFive { public static void main(String[] args) { FutureTask<Integer> futureTask = new FutureTask<>(() -> { int sum = 0; for (int i = 0; i < 100; i++) { sum += i; } return sum; }); new Thread(futureTask).start(); try { System.out.println(futureTask.get()); } catch (InterruptedException | ExecutionException e) { System.out.println("Error: " + e.getMessage()); } } }
6.线程安全问题
模拟妈妈摊10个煎饼儿子吃10个煎饼的场景
public static void main(String[] args) {
// 妈妈摊10煎饼
Thread mother = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("妈妈：摊了一个煎饼！");
NUM_PANCAKES++;
System.out.println("还剩：" + NUM_PANCAKES + "个煎饼！");
}
});
// 儿子吃10煎饼
Thread son = new Thread(() -> {
for (int i = 10; i > 0; i--) {
System.out.println("儿子：吃了一个煎饼！");
NUM_PANCAKES--;
System.out.println("还剩：" + NUM_PANCAKES + "个煎饼！");
}
});
mother.start();
son.start();
}结果：
多线程下对同一个共享资源的访问，会导致诸多线程安全问题：
-
数据竞争
多个线程访问同一内存位置，至少一个在写，没有合适的同步机制保护数据就会导致未定义的行为。
-
竞态条件
多个线程访问和操作共享顺序的操作非原子性(不可中断的操作)，那么就会导致不同的顺序不同的结果。
-
死锁
线程间互相等待对方的资源。吃饭需要碗和勺子，一个拿碗一个拿勺。
-
内存可见性
线程更改了共享变量的值，其他线程没有及时同步更新，读取的还是自己的缓存。
-
指令重排序
编译器和处理器可能会重新安排指令的执行顺序，多线程下会影响程序的正确性
7.线程间的通信
在Java中，可以使用wait()和notify()方法来实现线程间的同步通信。
用妈妈摊煎饼儿子吃煎饼，模拟线程间通信，同时确保煎饼只能摊一张吃一张的功能。
public class PancakeScenario {
// 共享资源：煎饼
private static boolean pancakeReady = false;
private static int NUM_PANCAKES_SUM = 0;
private static int NUM_PANCAKES_REST = 0;
public static void main(String[] args) {
// 妈妈：摊煎饼
Thread motherThread = new Thread(() -> {
while(true) {
synchronized(PancakeScenario.class) {
// 有煎饼，妈妈就等待
while (pancakeReady) {
try {
PancakeScenario.class.wait();
} catch (InterruptedException e) {
System.out.println("妈妈：等待失败...");
}
}
System.out.println("妈妈：烤煎饼中...");
// 煎饼摊好了，妈妈通知儿子
pancakeReady = true;
NUM_PANCAKES_REST++;
NUM_PANCAKES_SUM++;
System.out.println("还剩" + NUM_PANCAKES_REST + "个煎饼");
System.out.println("妈妈摊了" + NUM_PANCAKES_SUM + "个煎饼");
PancakeScenario.class.notify();
}
}
}, "motherThread");
// 儿子：吃煎饼
Thread childThread = new Thread(() -> {
while(true) {
synchronized(PancakeScenario.class) {
// 没煎饼，儿子就等待
while (!pancakeReady) {
try {
PancakeScenario.class.wait();
} catch (InterruptedException e) {
System.out.println("儿子：等待失败...");
}
}
System.out.println("儿子：吃煎饼中...");
// 煎饼吃完了，儿子通知妈妈
pancakeReady = false;
NUM_PANCAKES_REST--;
System.out.println("还剩" + NUM_PANCAKES_REST + "个煎饼");
System.out.println("儿子吃了" + NUM_PANCAKES_SUM + "个煎饼");
PancakeScenario.class.notify();
}
}
}, "childThread");
motherThread.start();
childThread.start();
}
}
8.Lock对象的介绍和基本使用
在Java中，Lock 接口提供了比内置的 synchronized 关键字更灵活的锁定机制。Lock 接口及其相关类位于 java.util.concurrent.locks 包中，提供了一系列高级功能，如公平锁、非阻塞锁、可中断锁等。
Lock 接口的主要方法
-
void lock()：获取锁。如果锁不可用，当前线程将被阻塞，直到锁可用。 -
void lockInterruptibly()：获取锁，如果锁不可用，当前线程将被阻塞，直到锁可用或被中断。 -
boolean tryLock()：尝试获取锁。如果锁可用，则立即返回true；如果锁不可用，则立即返回false。 -
boolean tryLock(long time, TimeUnit unit)：尝试获取锁，但在指定的等待时间内如果锁不可用，则返回false。 -
void unlock()：释放锁。
Lock 接口的实现类
-
ReentrantLock：最常用的Lock实现，支持重入。这意味着同一个线程可以多次获取同一个锁，而不会导致死锁。 -
ReentrantReadWriteLock：读写锁，允许多个读取者同时访问资源，但写入者独占资源。 -
StampedLock：提供乐观读锁、写锁和读锁，适用于高性能读多写少的场景
用lock改造摊煎饼场景：
public class PancakeScenarioUpgrade {
// 共享资源：煎饼
private static boolean pancakeReady = false;
// 锁对象
private static final Lock lock = new ReentrantLock();
public static void main(String[] args) {
// 妈妈线程：负责摊煎饼
Thread motherThread = new Thread(() -> {
while (true) {
lock.lock();
try {
while (pancakeReady) {
// 如果已经有煎饼了，妈妈就等待
try {
lock.unlock();
Thread.sleep(1000); // 模拟等待时间
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.lock();
}
}
// 摊煎饼
pancakeReady = true;
System.out.println("妈妈摊了一个煎饼");
} finally {
lock.unlock();
}
// 模拟摊煎饼的时间
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 儿子线程：负责吃煎饼
Thread sonThread = new Thread(() -> {
while (true) {
lock.lock();
try {
while (!pancakeReady) {
// 如果没有煎饼，儿子就等待
try {
lock.unlock();
Thread.sleep(1000); // 模拟等待时间
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.lock();
}
}
// 吃煎饼
pancakeReady = false;
System.out.println("儿子吃了煎饼");
} finally {
lock.unlock();
}
// 模拟吃煎饼的时间
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 启动线程
motherThread.start();
sonThread.start();
}
}9.避免忙等待
在改造的场景中，idea有一个提示信息：
// 在循环中使用Thread.sleep()可能会忙等待
Call to 'Thread.sleep()' in a loop, probably busy-waiting忙等待是指在一个循环中不断检查某个条件，直到该条件满足为止，而在此过程中线程不会放弃 CPU 时间片，也不会进入休眠状态。这种方式通常用于短时间的等待，或者在高实时性要求的场景中。它会导致CPU持续占用和性能损耗。
使用Condition 对象
可以使用Condition 对象，提供了更精确的等待和通知机制，避免 Thread.sleep() 的精度问题。
public class PancakeScenario {
// 共享资源：煎饼
private static boolean pancakeReady = false;
// 锁对象
private static final Lock lock = new ReentrantLock();
// 条件对象
private static final Condition pancakeReadyCondition = lock.newCondition();
public static void main(String[] args) {
// 妈妈线程：负责摊煎饼
Thread motherThread = new Thread(() -> {
while (true) {
lock.lock();
try {
while (pancakeReady) {
// 如果已经有煎饼了，妈妈就等待
pancakeReadyCondition.await();
}
// 摊煎饼
System.out.println("妈妈摊了一个煎饼");
pancakeReady = true;
// 通知儿子可以吃煎饼了
pancakeReadyCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
// 模拟摊煎饼的时间
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 儿子线程：负责吃煎饼
Thread sonThread = new Thread(() -> {
while (true) {
lock.lock();
try {
while (!pancakeReady) {
// 如果没有煎饼，儿子就等待
pancakeReadyCondition.await();
}
// 吃煎饼
System.out.println("儿子吃了煎饼");
pancakeReady = false;
// 通知妈妈可以摊新的煎饼了
pancakeReadyCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
// 模拟吃煎饼的时间
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 启动线程
motherThread.start();
sonThread.start();
}
}使用Timer
还是摊煎饼吧，儿子每隔10秒就跑去看煎饼是否摊好。
public static void main(String[] args) {
Thread son = new Thread(() -> {
while (true) {
try {
//看煎饼好了没
checkPancakeStatus();
Thread.sleep(1000L * 10);
} catch (Exception e) {
//print the error log
e.printStackTrace();
}
}
});
son.start();
}如果checkPancakeStatus方法抛出了异常就会跳过sleep()，那就没办法休眠，循环持续执行，在这个基础上，如果捕获异常打印了日志，还会导致日志撑爆磁盘。
还有一个要注意的坑，线程在sleep的过程中并不会释放所持有的锁，这会导致严重的并发问题，甚至是死锁。
推荐可以使用使用jdk自带的java.util.Timer解决：
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask(){
@Override
public void run() {
try {
//看煎饼好了没
checkPancakeStatus();
Thread.sleep(1000L * 10);
} catch (Exception e) {
//print the error log
e.printStackTrace();
}
}
}, 1000L * 10, 1000L * 10);
}