01 引言
多线程可以给我们带来速度的提升，同时线程的并发执行带来了资源共享、执行顺序和状态同步等复杂问题。有效的多线程控制是构建稳定、高效并发系统的基石。
控制不好，多线程翻车，因为共享变量造成数据的错乱，得不偿失。所以我们需要精准的控制多线程的执行顺序或者时机。
02 多线程顺序控制
控制的核心目标是协调线程对共享资源的访问、管理线程的生命周期、确保任务的正确执行顺序和结果一致性。
我们假设有两个线程A、B，因为多线程是无序运行的，我们通过睡眠时间让B线程先执行，A后执行。确保不加其他控制的输出顺序一定是先输出B，后输出A。然后通过不同的控制种类，让最终的输出结果为先输出A，后输出B。
// 线程A
Thread threadA = new Thread(() -> {
try {
Thread.sleep(2000);
System.out.println(DateUtil.now() + " thread1 执行");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
threadA.start();
// 线程B
Thread threadB = new Thread(() -> {
System.out.println(DateUtil.now() + " threadB 执行");
});
threadB.start();
运行结果：
2.1 Join方法
join()方法是线程的自带的方法，表示等待当前线程的生命周期结束，也就是执行完毕。
代码修改以及执行结果：
这种方式主要用在创建的独立线程，应用场景不广。
2.2 同步锁
同步锁需要借助synchronized 关键字，当synchronized 持有锁时，其他同步锁时无法执行的，只有等待被释放后才可以执行。
// 定义同步锁
Object lock = new Object();
Thread threadA = new Thread(() -> {
// 加锁操作
synchronized (lock) {
try {
Thread.sleep(2000);
System.out.println(DateUtil.now() + " threadA 执行");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
threadA.start();
Thread threadB = new Thread(() -> {
// 加锁操作
synchronized (lock) {
System.out.println(DateUtil.now() + " threadB 执行");
}
});
threadB.start();
2.3 互斥锁
互斥锁java.util.concurrent.locks.ReentrantLock，Java并发包下专门的工具。这个锁区别于同步锁，不能自动解锁，需要手动解锁。
ReentrantLock lock = new ReentrantLock();
Thread threadA = new Thread(() -> {
lock.lock();
try {
Thread.sleep(2000);
System.out.println(DateUtil.now() + " threadA 执行");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}finally {
lock.unlock();
}
});
threadA.start();
Thread threadB = new Thread(() -> {
lock.lock();
try {
System.out.println(DateUtil.now() + " threadB 执行");
}finally {
lock.unlock();
}
});
threadB.start();
03 多线程条件控制
多线的控制除了基本的共享资源或顺序的控制之外，还可以通过控制的多线程的数量或其他条件，来触发后续的业务逻辑。
3.1 信号量
信号量(Semaphore)，又被称为信号灯，在多线程环境下用于协调各个线程, 以保证它们能够正确、合理的使用公共资源。信号量维护了一个许可集，我们在初始化Semaphore时需要为这个许可集传入一个数量值，该数量值代表同一时间能访问共享资源的线程数量。
线程可以通过acquire()方法获取到一个许可，然后对共享资源进行操作。注意如果许可集已分配完了，那么线程将进入等待状态，直到其他线程释放许可才有机会再获取许可，线程释放一个许可通过release()方法完成，"许可"将被归还给Semaphore。
代码展示
Semaphore semaphore = new Semaphore(2);
for (int i = 0; i < 5; i++) {
semaphore.acquire();
AtomicInteger ai = new AtomicInteger(i);
new Thread(() -> {
System.out.println("-->" + DateUtil.now() + " 线程" + ai.get() + "执行了");
try {
Thread.sleep(2000);
semaphore.release();
System.out.println("释放信号量.....");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}).start();
}
运行结果
代码分析
案例定义了一次性处理2个线程的信号量new Semaphore(2)，当semaphore.acquire()将2个信号量取完时，就会阻塞，直到semaphore.release()信号被释放，就可以继续向下执行了。
可用于数据库连接池限制最大并发连接数，限流控制接口的最大并发数，停车场管理系统模拟车位等。
3.2 屏障
屏障(CyclicBarrier)，也叫栅栏，在JDK1.5被引入，可以让一组线程达到一个屏障时被阻塞，直到最后一个线程达到屏障时，所以被阻塞的线程才能继续执行。CyclicBarrier好比一扇门，默认情况下关闭状态，堵住了线程执行的道路，直到所有线程都就位，门才打开，让所有线程一起通过。
代码展示
CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> System.out.println(DateUtil.now() +" 线程准备就位...."));
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
AtomicInteger ai = new AtomicInteger(i);
new Thread(() -> {
try {
System.out.println("-->" + DateUtil.now() + " 线程" + ai.get() + "已就位...");
cyclicBarrier.await();
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("-->" + DateUtil.now() + " 线程" + ai.get() + "执行了");
}).start();
}
运行结果
代码分析
定义一个可以容纳2个线程的栅栏，现成进入栅栏之后，调用cyclicBarrier.await()阻塞，等待栅栏被打开。直到进入两个线程之后，栅栏被打开，开始执行后续的业务。栅栏又开始进入等待，循环往复。
我们会发现，最后一个线程就位以后就没有执行自己的业务，因为栅栏未被打开。
可以用在并行计算、多阶段任务所有线程完成阶段A后才能开始阶段B的业务场景。
3.3 条件变量
条件变量(Condition)，是 java.util.concurrent.locks.Condition 接口的一部分，它提供了等待（await）、信号（signal）和广播（signalAll）等方法。这些方法允许线程在满足特定条件之前挂起执行，并在条件满足时被唤醒。
而条件变量已经在CyclicBarrier被使用了，它是ReentrantLock的一个属性。
我们来看看如何使用。
代码展示
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
for (int i = 0; i < 5; i++) {
AtomicInteger ai = new AtomicInteger(i);
Thread.sleep(1000);
new Thread(() -> {
try {
lock.lock();
if (ai.get() == 4) {
System.out.println("----->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "唤醒其他所有线程...");
condition.signalAll();
}else {
System.out.println("-->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "已就位...");
condition.await();
}
System.out.println("-->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "执行了");
} catch (Exception e) {
throw new RuntimeException(e);
}finally {
lock.unlock();
}
}, "线程【" + i + "】").start();
}
运行结果
代码分析
让线程在某个条件不满足时主动等待，并在条件可能满足时被唤醒，必须与互斥锁配合使用。案例限制的是进入都必须等待，直到最后一个线程的时候，唤醒其他线程执行业务。
3.4 闭锁
闭锁（CountDownLatch）是Java多线程并发中的一种同步器，它是JDK内置的同步器。通过它可以定义一个倒计数器，当倒计数器的值大于0时，所有调用await方法的线程都会等待。而调用countDown方法则可以让倒计数器的值减一，当倒计数器值为0时所有等待的线程都将继续往下执行。
代码展示
CountDownLatch count = new CountDownLatch(3);
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
new Thread(() -> {
System.out.println("----->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "已就位...");
count.countDown();
try {
count.await();
System.out.println("-->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "执行了");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}, "线程【" + i + "】").start();
}
运行结果
代码分析
线程进入之后，都会进行计数器减1的操作（count.countDown()），然后调用count.await()等待计数器清零。清零后就不在受CountDownLatch的影响了。
可以用于等待所有的线程执行完任务之后，计数器清零后，再继续其他业务。
3.5 读写锁
读写锁(ReentrantReadWriteLock)，是专门针对读多写少的场景设计的，采用读写分离的策略，允许多个线程可以同时获取读锁。
代码展示
ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock();
Lock writeLock = rwLock.writeLock();
Map<String, String> cache = new HashMap<>();
for (int i = 0; i < 5; i++) {
AtomicInteger ai = new AtomicInteger(i);
new Thread(() -> {
writeLock.lock();
try {
String value = cache.get("name");
cache.put("name", "test" + ai.get());
System.out.println("-->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "执行了: oldValue=" + value + ", newValue="+ cache.get("name"));
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
writeLock.unlock();
}
}, "线程B【" + i + "】").start();
}
for (int i = 0; i < 5; i++) {
new Thread(() -> {
readLock.lock();
try {
String value = cache.get("name");
System.out.println("-->" + DateUtil.now() + " 线程" + Thread.currentThread().getName() + "执行了: value=" + value);
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
readLock.unlock();
}
}, "线程A【" + i + "】").start();
}
// 主线程阻塞
System.in.read();
运行结果
代码解析
从案例代码中可以看出，每一次读和写之后都是有1s的休眠时间。读锁是在写锁被全部释放之后，才能占有读锁。读锁不受休眠线程线程的影响，也就是不受同一个读锁的限制。
而写锁相互影响，必须等待上一个写锁被释放后才会占用锁。
可用于缓存系统（频繁读取，偶尔更新）、配置中心（大量服务读取配置，管理员偶尔更新）等场景。
04 小结
多线程控制是并发编程的核心技能。理解不同控制机制（锁、信号量、屏障等）的原理和适用场景至关重要。通过有效的日志、监控工具和可视化手段“显示”控制过程，是开发、调试和运维高并发系统的关键。
在实际业务中，往往需要组合多种控制机制，并持续监控和调优，才能在享受并发带来的性能提升的同时，保证系统的正确性、稳定性和可维护性。没有银弹，只有最适合场景的解决方案。
多线程运用的好，高并发场景你就入门了。
扫一扫
1349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
