目录
1. 进程与线程
1.1 进程
进程：是操作系统中的最小单位。通过进程可以创建程序的应用。
一个进程是一个独立的执行单位，它拥有独立的内存空间和系统资源。每个进程都在操作系统中分配了独立的资源，包括内存、文件句柄、设备和网络连接等。在Java中，可以使用ProcessBuilder类或Runtime.getRuntime().exec()方法创建和控制进程。
1.2 线程
线程：线程是进程中的最小单位，一个进程中可以包含多个线程，并且可以同时执行，此时就形成了多线程状态。
一个线程是进程中的一个执行路径，一个进程可以有多个线程。线程共享进程的内存空间和系统资源，可以在同一进程中访问和修改共享数据。在Java中，每个线程都对应一个Thread对象，可以通过创建这个对象并调用其start()方法来创建和启动线程。
1.3 并发与并行
并发：是指多个任务在同一时间段内交替执行的能力。在单个处理器系统中，由于任务的执行速度非常快，我们会有一种错觉认为多个任务是同时执行的。实际上，处理器通过快速地在不同任务之间进行切换，以达到多个任务交替执行的效果，从而给人一种同时执行的感觉。
并行：并行是指多个任务同时执行的能力。在多处理器系统或者多核处理器上，多个任务可以真正地同时执行，每个处理器或核心负责执行一个任务，从而提高整体的处理速度。
2. 多线程
2.1 多线程的概念
在Java中，多线程是指程序中同时执行多个线程的能力。位，一个进程可以包含多个线程。使用多线程可以让程序在同一时间内执行多个任务，从而提高程线程是计算机执行代码的最小单序的执行效率。
2.2 多线程的好处
使用多线程有以下几个好处：
1. 提高程序的执行效率：通过多线程，可以让程序同时执行多个任务，利用多核处理器的并行计算能力，从而提高程序的整体执行效率。多线程可以使程序在某些情况下快速响应用户操作，提高用户体验。
2. 充分利用 CPU 时间片：在单线程环境下，当一个线程的任务没有执行完毕时，CPU 会一直等待，导致 CPU 时间片的浪费。而多线程可以让不同的线程在互相切换的同时执行任务，充分利用 CPU 时间片，提高 CPU 的利用率。
3. 并发处理：多线程可以实现并发处理，即同时处理多个任务。这在需要同时处理多个请求或者执行多个并行任务时非常有用，比如服务器处理多个客户端请求、下载文件时同时进行网络请求和数据处理等。
4. 提高资源利用率：某些任务需要等待资源，比如网络请求、文件读写等操作，单线程下会导致等待时间增加。多线程可以在一个线程等待时，切换到其他线程执行任务，充分利用 CPU 和其他资源，减少等待时间。
5. 提高系统的可响应性：当一个任务执行时间较长时，单线程会使得整个系统变得不可响应，因为该线程一直在执行任务，无法响应其他的操作。而多线程允许同时执行多个任务，可以保持系统的可响应性，及时响应用户的操作。
6.带来良好的用户体验。
需要注意的是，多线程并不是适用于所有的情况，过多的线程可能导致资源竞争、死锁等问题。在设计和实现多线程程序时，需要仔细考虑线程同步、资源管理等问题，确保多线程程序的正确性和稳定性。
2.3 主线程
主线程是指程序启动时自动创建的线程，也称为主线程或者主程序线程。它是程序的入口点，负责执行程序的主要逻辑。在Java中，主线程是指main()方法所在线程。
主线程是程序的入口点，负责执行主要的程序逻辑，创建和管理其他线程，处理用户输入和显示界面等任务。它在程序的生命周期中起着重要的作用。
3. 线程的创建与启动
3.1 继承Thread类
要创建一个继承Thread类的线程，需要完成以下步骤：
- 创建一个继承自Thread类的子类，并重写其中的
run()方法，run()方法中定义了线程要执行的代码。class MyThread extends Thread { // 重写run方法 @Override public void run() { // 线程要执行的代码 } } - 在主程序中，创建子类的实例，并调用
start()方法来启动线程。public class Main { public static void main(String[] args) { MyThread thread = new MyThread(); // 启动线程 thread.start(); } }
- 优点：
- 直观简单：使用继承Thread类的方式创建线程，代码相对简单直观，直接就可以进行调用。
-
可以直接访问线程的实例：通过继承Thread类，可以直接访问线程的实例，方便在代码中对线程的状态等信息进行操作。
-
方便使用线程相关方法：Thread类提供了很多与线程相关的方法，例如
sleep()、yield()、join()等，继承Thread类可以直接使用这些方法，方便对线程的控制和管理。
- 缺点：
-
缺乏灵活性：单继承，由于Java不支持多继承，继承了Thread类后就无法再继承其他类。这限制了线程类在继承结构上的灵活性，不利于代码的扩展和复用。
-
无法共享资源：每个继承Thread类创建的线程都有自己独立的对象实例，无法直接共享实例变量和方法。如果需要共享资源，需要使用静态变量或者其他的同步机制。
-
不能作为任务对象：继承Thread类的方式，线程的执行逻辑和实例对象是紧耦合的，线程对象本身不能作为任务对象被传递给其他组件使用。
-
耦合度高：由于继承Thread类创建线程，导致线程与任务逻辑紧耦合在一起，不利于代码的模块化和单元测试。
3.2 实现Runnable接口
使用实现Runnable接口创建线程的步骤：
- 创建一个实现Runnable接口的类，并实现其中的
run()方法，run()方法中定义线程要执行的代码。class MyRunnable implements Runnable { // 重写run方法 @Override public void run() { // 线程要执行的代码 } } - 在主程序中，创建该类的实例，并将其作为参数传递给Thread类的构造函数，创建Thread对象。
public class Main { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); // 启动线程 thread.start(); } }
- 优点：
- 灵活性高：可以实现多继承，相比继承Thread类，实现Runnable接口的方式更加灵活，因为一个类可以同时实现多个接口，不受Java单继承的限制，方便代码的扩展和复用。
- 资源共享：通过实现Runnable接口创建的多个线程可以共享同一个Runnable对象实例，方便资源的共享和传递。
- 代码解耦：实现Runnable接口将线程的执行逻辑和线程对象实例解耦，更有利于代码的模块化和单元测试。
- 缺点：
缺少一些线程相关的方法：相比继承Thread类，实现Runnable接口的类无法直接调用一些与线程相关的方法，例如sleep()、yield()、join()等，需要通过Thread对象来调用。
3.3 实现Callable接口
实现Callable接口是另一种创建线程的方式。与实现Runnable接口相比，实现Callable接口的线程可以返回执行结果。
以下是使用实现Callable接口创建线程的步骤：
- 创建一个实现Callable接口的类，并实现其中的call()方法，call()方法中定义线程要执行的代码，并返回执行结果的类型。
package com.csi.callable; import java.util.concurrent.Callable; public class SumCallable implements Callable<Integer> { private int num; public SumCallable(int num){ this.num = num; } @Override public Integer call() throws Exception { // 接收总值 int sum = 0; // 计算从1 - num 的总和 for (int i = 1; i <= num; i++) { sum += i; } return sum; } } - 在主程序中，创建该类的实例，创建线程池，提交任务到线程池并获取Future对象，获取并输出任务的执行结果，关闭线程池。
package com.csi.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建线程缓冲池
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 创建任务
SumCallable sc = new SumCallable(100);
// 提交任务到线程池并返回Future对象
Future<Integer> submit = executorService.submit(sc);
// 打印输入1 - num 的总和
System.out.println("总和为:" + submit.get());
//关闭线程池
executorService.shutdown();
}
}
或者：创建该类的实例，并将其作为参数传递给FutureTask类的构造函数，创建FutureTask对象。
import java.util.concurrent.FutureTask;
public class Main {
public static void main(String[] args) {
MyCallable myCallable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start(); // 启动线程
try {
// 获取线程的执行结果
Integer result = futureTask.get();
System.out.println("线程执行结果：" + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}- 优点：
- 可返回执行结果：相比实现Runnable接口，实现Callable接口的线程可以返回执行结果，方便获取线程的执行结果。
- 异常处理更灵活：`FutureTask`的`get()`方法可以捕获线程抛出的异常，方便进行异常处理。
- 缺点：
代码相对复杂：相比实现Runnable接口，实现Callable接口需要多一些代码，包括借助`FutureTask`类来获取线程的执行结果。
3.4 run方法调用和start调用的区别
run方法是定义在线程类中，作为自定义线程，需要重写run方法，如果直接通过main主线程调用，就和调用普通的对象方法是一样的，并不会让线程单独启动。
而start方法是定义在Thread类中的，通过start方法，jvm虚拟机会自动的调用run方法，执行线程任务，所以该种方式是能够实现多线程的方式。一个线程不能够重复执行。
4.线程的状态
4.1 线程状态概述
public class Thread implements Runnable {
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}Java中的线程状态有以下几种：
- New（新建状态）：当线程对象被创建但还未开始执行时，线程处于新建状态。这是线程对象被实例化后的初始状态。
- Runnable（可运行状态）：当线程正在执行或可执行时，线程处于可运行状态。在可运行状态下，线程还可能正在等待其他系统资源（例如处理器时间片）。
- Blocked（阻塞状态）：当线程被阻塞并等待某个监视器锁时，线程处于阻塞状态。此时，线程暂时停止执行并等待某个条件的满足，如等待其他线程释放锁。
- Waiting（等待状态）：当线程在某个条件下无限期地等待另一个线程的特定动作时，线程处于等待状态。线程将等待其他线程显式地唤醒（通过调用`notify()`或`notifyAll()`方法）。
- Timed Waiting（计时等待状态）：当线程在某个条件下等待一段时间，在指定时间内会自动唤醒时，线程处于计时等待状态。线程可以在指定时间后自动醒来，或者可以被其他线程显式地唤醒。
- Terminated（终止状态）：当线程的`run()`方法执行完毕或线程被提前终止时，线程处于终止状态。在这个状态下，线程的生命周期已经结束。
请注意，阻塞、等待和计时等待状态是由于线程执行的不同方法和条件的不同操作引起的。
4.2 等待和唤醒
可以使用wait()和notify()（或notifyAll()）方法来实现线程的等待和唤醒，从而实现线程间的协作。
wait()方法使当前线程进入等待状态，放弃锁，并等待其他线程调用相同对象上的notify()或notifyAll()方法来唤醒它。
notify()方法用于唤醒等待在同一对象上的一个等待线程，而notifyAll()方法则唤醒所有等待在同一对象上的线程。
以下是使用wait()和notify()方法实现线程等待和唤醒的示例代码：
Object lock = new Object(); // 共享的对象锁
Thread waitingThread = new Thread(() -> {
synchronized (lock) {
try {
// 等待其他线程唤醒
lock.wait();
// 被唤醒后继续执行
} catch (InterruptedException e) {
// 处理异常
}
}
});
Thread notifyingThread = new Thread(() -> {
synchronized (lock) {
// 执行需要在等待线程唤醒之后进行的操作
// ...
// 唤醒等待中的线程
lock.notify();
}
});
// 启动等待线程和唤醒线程
waitingThread.start();
notifyingThread.start();案例：
定义一个集合，包子铺线程完成生产包子，包子添加到集合中；吃货线程完成购买包子，包子从集合中移除。1. 当包子没有时（包子状态为 false ），吃货线程等待 .2. 包子铺线程生产包子（即包子状态为 true ），并通知吃货线程（解除吃货的等待状态）
包子铺类：
/**
* 包子铺，生产包子
*/
public class BaoZiPu extends Thread{
private List<String> list;
public BaoZiPu(List<String> list) {
this.list = list;
}
@Override
public void run() {
while (true){
synchronized (list){
if (list.size() > 0){
try {
// 停止生产
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
list.add("包子");
System.out.println("生产了一个包子....");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// 通知吃货消费包子
list.notify();
}
}
}
}
吃货类：
/**
* 吃货，消费包子
*/
public class ChiHuo extends Thread{
private List<String> list;
public ChiHuo(List<String> list) {
this.list = list;
}
@Override
public void run() {
while (true){
synchronized (list){
if (list.size() == 0){
try {
// 没有包子可以消费，停止
list.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
list.remove(0);
System.out.println("吃货吃了一个包子.....");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// 通知包子铺生产包子
list.notify();
}
}
}
}
测试类：
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
BaoZiPu baoZiPu = new BaoZiPu(list);
ChiHuo chiHuo = new ChiHuo(list);
baoZiPu.start();
chiHuo.start();
}
}
5. 线程调度
5.1 setPriority
可以使用setPriority(int priority)方法来更改线程的优先级，其中priority参数表示线程的优先级。线程的优先级范围是1到10，其中1是最低优先级，10是最高优先级。默认情况下，线程的优先级是5。
Thread thread1 = new Thread(tr1,"线程优先级高") ;
//设置线程的优先级
thread1.setPriority(10);
System.out.println(thread1.getPriority());
thread1.start();5.2 sleep
可以使用Thread.sleep(long milliseconds)方法将当前线程置于休眠状态。milliseconds参数表示线程要休眠的时间，单位是毫秒。
try {
Thread.sleep(2000); // 将当前线程休眠2秒
} catch (InterruptedException e) {
// 处理异常
throw new RuntimeException(e);
}5.3 join
可以使用join()方法将一条线程插入到当前正在运行的线程中，并等待该线程执行完毕，然后再继续执行当前线程。join()方法的效果是将两条线程合并，使得当前线程等待其他线程的完成。
Thread thread = new Thread(() -> {
// 其他线程要执行的任务
});
thread.start(); // 启动其他线程
// 当前线程插入到其他线程中，等待其他线程执行完毕
try {
thread.join();
} catch (InterruptedException e) {
// 处理异常
throw new RuntimeException(e);
}
// 当其他线程执行完毕后，继续执行当前线程的任务public void sleep(){
while (true) {
//每秒睡一次
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Date date = new Date();
System.out.println(date);
}
}
main:
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "=" + i);
if(i == 5) {
try {
st.join(); //强势性，插入执行后，其他线程全部等待
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}5.4 yield
可以使用Thread.yield()方法来暂停当前正在执行的线程，让其他线程有机会运行。调用yield()方法会提示调度器，表明当前线程愿意放弃一部分的CPU执行时间，给其他线程执行的机会，但是并不能保证一定会礼让。
Thread thread = new Thread(() -> {
// 其他线程要执行的操作
});
thread.start(); // 启动其他线程
// 当前线程使用yield()方法礼让其他线程执行
Thread.yield();
// 继续当前线程的执行for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "=" + i);
if(i == 5) {
Thread.yield();
}
} 5.5 interupt
可以通过调用线程的interrupt()方法来中断线程。interrupt()方法会设置线程的中断标志，表示线程被请求中断。
Thread thread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
// 线程要执行的任务
// 在任务中检查中断标志
if (Thread.currentThread().isInterrupted()) {
// 执行中断后的逻辑
break;
}
}
});
thread.start(); // 启动线程
// 中断线程
thread.interrupt();5.6 isAlive
可以使用isAlive()方法来判断一个线程是否存活。isAlive()方法返回一个布尔值，表示线程是否处于活动状态。
Thread thread = new Thread(() -> {
// 线程要执行的任务
});
thread.start(); // 启动线程
// 判断线程是否存活
if (thread.isAlive()) {
// 线程存活的处理逻辑
} else {
// 线程不存活的处理逻辑
}6. volatile关键字
6.1 volatile
volatile是Java中的一个关键字，用来标记一个变量，表示该变量是被多个线程共享的，具有可见性和防止指令重排序的特性。
当一个变量被声明为volatile时，对该变量的写操作将立即刷新到主内存中，而不是先写入线程的本地缓存。同时，对volatile变量的读操作将从主内存中获取最新值，而不是从线程的本地缓存中读取。这样可以确保在一个线程修改了一个volatile变量的值后，其他线程能够立即看到这个修改。
以下是使用volatile关键字的示例：
public class SharedData {
private volatile int counter = 0;
public void increment() {
counter++;
}
public int getCounter() {
return counter;
}
}volatile 虽然保证了可见性，但并
没有保证操作的原子性，还是会出现 A、B 线程同时读取到共享数据，然后各自修改导致结果覆盖的问题，所以无法保证线程安全。
volatile 实际适用场景主要可以结合 CAS 操作，提高并发的性能，就如同 Java concurrent 类库中的用法，因为 volatile 的性能是很轻量的，能够避免 CAS 操作因为数据的可见性问题而导致失败。
6.2 JMM
JMM主要关注以下几点：
-
可见性（Visibility）：JMM通过提供可见性的保证，确保一个线程对共享变量的修改能够被其他线程及时地看到。
volatile关键字和synchronized关键字都可以实现可见性。 -
有序性（Ordering）：JMM规定了指令重排序的限制，保证了程序执行的顺序在单个线程内（线程内顺序语义）和不同线程间（线程间顺序语义）是一致的。
volatile关键字和synchronized关键字都可以实现有序性。 -
原子性（Atomicity）：JMM通过提供对基本类型变量的原子性操作保证，确保对于某些操作的执行是不可分割的，要么全部执行成功，要么不执行。
6.3 volatile与synchronized
7. 原子性
7.1 概述
原子性是指一个操作或者一系列操作在执行过程中不会被其他线程干扰，要么完整地执行，要么完全不执行，不会出现中间状态。
在多线程的环境下，多个线程同时对共享的数据进行读写操作时，可能会导致数据的不一致性或者竞态条件（race condition）。为了避免这些问题，需要保证某些操作的原子性，即要么全部执行成功，要么全部不执行。
Java中提供了多种机制来实现原子性操作：
1. synchronized关键字：通过使用`synchronized`关键字，可以保证被`synchronized`修饰的方法或者代码块在同一时刻只能被一个线程访问，从而保证操作的原子性。
2. Atomic类：Java.util.concurrent.atomic包中提供了一系列的Atomic类，如AtomicInteger、AtomicLong等，它们提供了一些原子性操作，比如compareAndSet()、getAndIncrement()等，可以保证多线程环境下的原子性操作。
3. Lock接口：Java提供的Lock接口和它的实现类如ReentrantLock可以用来实现互斥锁，从而保证在同一时刻只有一个线程可以获取锁并执行操作，其他线程则需要等待。
需要注意的是，原子性操作不仅仅局限于基本类型的操作，还可以是复合操作，比如对一个对象的多个属性进行修改，这种情况下，需要利用synchronized、Lock或者其他同步机制来保证操作的原子性。
通过保证操作的原子性，可以有效避免数据竞争和并发问题，确保多线程环境下程序的正确性和一致性。
public class VolatileAtomicThread implements Runnable {
// 定义一个int类型的变量
private AtomicInteger atomicInteger = new AtomicInteger() ;
@Override
public void run() {
// 对该变量进行++操作，100次
for(int x = 0 ; x < 100 ; x++) {
int i = atomicInteger.getAndIncrement();
System.out.println("count =========>>>> " + i);
}
}
}7.2 原子类CAS机制实现线程安全
CAS（Compare and Swap）机制是一种用于实现多线程环境下的线程安全的原子操作。
CAS操作包括三个操作数：内存地址（或者称为期望值）、原始值和新值。CAS首先比较内存中的值是否与期望值相等，如果相等，则使用新值替换内存中的值；如果不相等，则说明内存中的值已经被其他线程修改，CAS操作失败，不进行替换。
Java中的原子类（如AtomicInteger、AtomicLong等）利用CAS机制实现了原子操作。这些原子类提供了一系列的原子性操作方法，如compareAndSet()、getAndIncrement()等。
下面是使用CAS机制实现线程安全的示例：
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}7.3 CAS与Synchronized：乐观锁，悲观锁
CAS和synchronized是实现并发编程中乐观锁和悲观锁的两种不同方式。
-
CAS（乐观锁）：
- CAS机制是一种乐观锁机制，它假设多个线程之间的冲突很少发生。
- 在CAS中，线程在操作共享数据之前，先比较当前值与期望值是否相等，如果相等，则进行更新，否则认为存在冲突，不进行更新。
- 当多个线程并发地使用CAS操作时，只有一个线程能够成功执行更新操作，其他线程需要重试或执行其他操作。
-
synchronized（悲观锁）：synchronized关键字是一种悲观锁机制，它假设多个线程会频繁地出现冲突，所以需要使用锁来保护共享资源。- 在
synchronized中，线程在进入同步代码块或方法之前，会先申请锁，如果获取到锁就可以执行操作，其他线程需要等待锁的释放。 - 当一个线程释放锁时，其他线程才能获取锁继续执行操作。
8. 并发包
Java并发包（java.util.concurrent）是Java提供的用于处理并发编程的工具集合。该包提供了一系列类和接口，用于实现线程安全和高效的并发操作，包括线程池、原子类、阻塞队列、并发集合等。
8.1 ConcurrentHashMap
ConcurrentHashMap是Java并发包中一个线程安全的哈希表实现，它是对HashMap的线程安全改造。
它具有以下特点：
-
线程安全性：ConcurrentHashMap是线程安全的，多个线程可以同时读取和写入其中的数据，而无需额外的同步机制。不同于HashMap，在ConcurrentHashMap中同时进行读写操作不会导致数据不一致性或抛出ConcurrentModificationException异常。
-
分段锁设计：ConcurrentHashMap的线程安全性是通过分段锁机制实现的。内部将数据分成多个段（Segment），每个段相当于一个小的HashMap。每个段都有一个锁用于控制对该段的操作。在并发情况下，不同的线程可以同时对不同的段进行读写操作，从而提高并发性能。
-
增强的迭代器：ConcurrentHashMap的迭代器是弱一致性的。当ConcurrentHashMap在遍历过程中发生修改操作时，迭代器会尽力反映最新的更新，但不提供满足严格一致性的保证。
-
支持高并发：ConcurrentHashMap在并发情况下能够提供很好的性能和扩展性，适用于高并发环境。
演示：
public class Const {
public static ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>
();
}public void run() {
long start = System.currentTimeMillis();
for (int i = 0; i < 500000; i++) {
Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
}
long end = System.currentTimeMillis();
System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫
秒");
}测试类：
public class Demo {
public static void main(String[] args) throws InterruptedException {
Thread1A a1 = new Thread1A();
Thread1A a2 = new Thread1A();
a1.setName("线程1-");
a2.setName("线程2-");
a1.start();
a2.start();
// 休息10秒，确保两个线程执行完毕
Thread.sleep(1000 * 5);
// 打印集合大小
System.out.println("Map大小：" + Const.map.size());
}
}8.2 CountDownLatch
CountDownLatch（倒计时门闩）是Java并发包中的一个同步工具类，用于控制线程之间的协作。它提供了一种等待其他线程完成操作的机制，实现了线程的阻塞和解除阻塞。
CountDownLatch的工作原理如下：
- 创建一个CountDownLatch对象，需要指定计数器的初始值。
- 主线程调用CountDownLatch的
await()方法，进入等待状态，直到倒计时计数器为0。 - 减1。其他线程执行完特定的任务后，调用CountDownLatch的
countDown()方法，将倒计时计数器 - 当倒计时计数器减到0时，主线程的阻塞状态被解除，继续执行后续操作。
例如：线程 1 要执行打印： A 和 C ，线程 2 要执行打印： B ，但线程 1 在打印 A 后，要线程 2 打印 B 之后才能打印C ，所以：线程 1 在打印 A 后，必须等待线程 2 打印完 B 之后才能继续执行。
public class ThreadA extends Thread {
private CountDownLatch down ;
public ThreadA(CountDownLatch down) {
this.down = down;
}
@Override
public void run() {
System.out.println("A");
try {
down.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("C");
}
}public class ThreadB extends Thread {
private CountDownLatch down ;
public ThreadB(CountDownLatch down) {
this.down = down;
}
@Override
public void run() {
System.out.println("B");
down.countDown();
}
}public class Demo {
public static void main(String[] args) {
CountDownLatch down = new CountDownLatch(1);//创建1个计数器
new ThreadA(down).start();
new ThreadB(down).start();
}
}8.3 CyclicBarrier
CyclicBarrier（循环屏障）是Java并发包中的一个同步工具类，用于控制线程之间的协作。它与CountDownLatch类似，也是通过计数器的方式来控制线程的阻塞和解除阻塞，但与CountDownLatch不同的是，CyclicBarrier的计数器可以重复使用。
CyclicBarrier的工作原理如下：
- 创建一个CyclicBarrier对象，需要指定计数器的初始值和当计数器归零时需要执行的动作（可选）。
- 多个线程同时调用CyclicBarrier的
await()方法，线程进入等待状态。 - 当计数器达到初始值时，所有等待的线程同时被释放，并可以继续执行后续操作。
- 计数器归零后，CyclicBarrier可以被重复使用。
例如：公司召集 5 名员工开会，等 5 名员工都到了，会议开始。我们创建 5 个员工线程， 1 个开会线程，几乎同时启动，使用 CyclicBarrier 保证 5 名员工线程全部执行后，再执行开会线程。
制作员工线程：
public class PersonThread extends Thread {
private CyclicBarrier cbRef;
public PersonThread(CyclicBarrier cbRef) {
this.cbRef = cbRef;
}
@Override
public void run() {
try {
Thread.sleep((int) (Math.random() * 1000));
System.out.println(Thread.currentThread().getName() + " 到了! ");
cbRef.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}public class MeetingThread extends Thread {
@Override
public void run() {
System.out.println("好了，人都到了，开始开会......");
}
}public class Demo {
public static void main(String[] args) {
CyclicBarrier cbRef = new CyclicBarrier(5, new MeetingThread());//等待5个线程，执行完毕，再执行MeetingThread
PersonThread p1 = new PersonThread(cbRef);
PersonThread p2 = new PersonThread(cbRef);
PersonThread p3 = new PersonThread(cbRef);
PersonThread p4 = new PersonThread(cbRef);
PersonThread p5 = new PersonThread(cbRef);
p1.start();
p2.start();
p3.start();
p4.start();
p5.start();
}
}8.4 Semaphore
Semaphore（信号量）是一种在并发编程中常用的同步工具，用于控制对共享资源的访问。与锁（Lock）不同，Semaphore不是基于互斥的原则来控制资源的访问，而是基于计数器的原理。
public Semaphore(int permits) permits 表示许可线程的数量
public Semaphore(int permits, boolean fair) fair 表示公平性，如果这个设为 true
的话，下次执行的线程会是等待最久的线程public void acquire() throws InterruptedException 表示获取许可
public void release() release() 表示释放许可示例：
public class Service {
private Semaphore semaphore = new Semaphore(1);//1表示许可的意思，表示最多允许1个线程，执行acquire()和release()之间的内容
public void testMethod() {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + " 进入 时间=" + System.currentTimeMillis());
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 结束 时间=" + System.currentTimeMillis());
semaphore.release();
//acquire()和release()方法之间的代码为"同步代码"
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}public class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}public class Demo {
public static void main(String[] args) {
Service service = new Service();
//启动5个线程
for (int i = 1; i <= 5; i++) {
ThreadA a = new ThreadA(service);
a.setName("线程 " + i);
a.start();//5个线程会同时执行Service的testMethod方法，而某个时间段只能有1个线程执行
}
}
}8.5 Exchanger
Exchanger（交换器）是Java并发包中提供的同步工具之一，用于两个线程之间交换数据。它提供了一个简单的线程间数据交换的模型，在一个线程中调用exchange()方法时会阻塞，直到另一个线程也调用了exchange()方法，然后进行数据的交换。
Exchanger的主要特点如下：
- Exchanger只能用于两个线程之间的数据交换，需要同时有两个线程调用
exchange()方法才能完成交换。 - 交换的数据可以是任意类型，可以是对象、集合、基本类型等。
- 调用
exchange()方法时，如果没有与之配对的线程准备进行交换，则当前线程会被阻塞，直到有与之配对的线程来进行交换。
public Exchanger()public V exchange(V x)exchange 方法执行交换
public class ThreadA extends Thread {
private Exchanger<String> exchanger;
public ThreadA(Exchanger<String> exchanger) {
super();
this.exchanger = exchanger;
}
@Override
public void run() {
try {
System.out.println("线程A欲传递值'礼物A'给线程B，并等待线程B的值...");
System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("礼物A"));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}public class ThreadB extends Thread {
private Exchanger<String> exchanger;
public ThreadB(Exchanger<String> exchanger) {
super();
this.exchanger = exchanger;
}
@Override
public void run() {
try {
System.out.println("线程B欲传递值'礼物B'给线程A，并等待线程A的值...");
System.out.println("在线程B中得到线程A的值=" + exchanger.exchange("礼物B"));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}public class Demo {
public static void main(String[] args) throws InterruptedException {
Exchanger<String> exchanger = new Exchanger<String>();
ThreadA a = new ThreadA(exchanger);
ThreadB b = new ThreadB(exchanger);
a.start();
b.start();
}
}9. 线程池
9.1 线程池
线程池是一种线程管理的机制，它可以预先创建一组线程，在需要执行任务时，从线程池中获取线程来执行任务，而不是每次都创建新线程。这种方式可以避免频繁创建和销毁线程的开销，提高线程的复用性和执行效率。
好处：
-
降低线程创建和销毁的开销：线程的创建和销毁是有开销的，包括内存分配、资源绑定等操作。通过使用线程池，可以重用已创建的线程，避免频繁创建和销毁线程的开销，提高系统的性能和效率。
-
提高线程的复用性：线程池可以将线程进行管理和复用，当一个任务执行完毕后，线程可以立即被分配到下一个任务上，不需要等待线程的创建和销毁，从而减少线程的等待时间，提高线程的复用性。
-
控制并发线程数量：线程池可以限制同时执行的任务数，通过设置线程池的线程数目，可以防止系统资源过度占用和线程数量过多导致的性能下降。这样可以合理分配系统资源，提高系统整体的稳定性和可伸缩性。
-
提供更多的任务调度和管理功能：线程池提供了丰富的任务调度和管理功能，如定时执行任务、延迟执行任务、取消任务等。同时，线程池还可以监控任务的执行情况，获取任务执行的结果（通过
Future对象），便于后续的处理。 -
提供线程执行的统一管理：通过线程池，可以将线程的执行和资源的管理集中在一个地方，方便统一管理和监控线程的状态、异常等。同时，线程池提供了优雅地关闭线程池的方法，保证线程的正常停止和资源的释放。
9.2 线程池的使用步骤
- 创建线程池对象。
- 创建Runnable接口子类对象。(task)
- 提交Runnable接口子类对象。(take task)
- 关闭线程池(一般不做)。
例子：
需求: 使用线程池方式执行任务,返回1-n的和
分析 : 因为需要返回求和结果 , 所以使用 Callable 方式的任务
public class SumCallable implements Callable<Integer> {
private int num;
public SumCallable(int num){
this.num = num;
}
@Override
public Integer call() throws Exception {
// 接收总值
int sum = 0;
// 计算从1 - num 的总和
for (int i = 1; i <= num; i++) {
sum += i;
}
return sum;
}
}public class TestCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建线程缓冲池
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 创建任务
SumCallable sc = new SumCallable(100);
// 提交任务到线程池并返回Future对象
Future<Integer> submit = executorService.submit(sc);
// 打印输入1 - num 的总和
System.out.println("总和为:" + submit.get());
//关闭线程池
executorService.shutdown();
}
}10. 死锁
10.1 概念
死锁指的是在并发编程中，两个或多个线程互相持有对方需要的资源，并且无法继续执行下去的一种状态。在死锁状态下，所有的线程都被阻塞，无法继续执行，只能等待其他线程释放所持有的资源。
10.2 产生条件
- 互斥条件（Mutual Exclusion）：至少有一个资源是独占的，即一次只能被一个线程持有。
- 请求与保持条件（Hold and Wait）：线程至少持有一个资源，并且在等待其他线程释放资源时不释放自己持有的资源。
- 不可剥夺条件（No Preemption）：线程所获得的资源不能被强制性地抢占，只能自愿释放。
- 循环等待条件（Circular Wait）：线程之间存在一个循环等待资源的关系，形成一个闭环。
10.3 死锁代码
public class Demo05 {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
new Thread(mr).start();
new Thread(mr).start();
}
}
class MyRunnable implements Runnable {
Object objA = new Object();
Object objB = new Object();
/*
嵌套1 objA
嵌套1 objB
嵌套2 objB
嵌套1 objA
*/
@Override
public void run() {
synchronized (objA) {
System.out.println("嵌套1 objA");
synchronized (objB) {// t2, objA, 拿不到B锁,等待
System.out.println("嵌套1 objB");
}
}
synchronized (objB) {
System.out.println("嵌套2 objB");
synchronized (objA) {// t1 , objB, 拿不到A锁,等待
System.out.println("嵌套2 objA");
}
}
}
642
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
