深入理解Java内存模型及其在多线程编程中的应用
今天我们来深入探讨Java内存模型（Java Memory Model, JMM）及其在多线程编程中的应用。
一、Java内存模型概述
Java内存模型（JMM）是Java虚拟机规范的一部分，定义了变量的访问方式及线程之间如何协同工作。JMM为多线程编程提供了抽象的内存视图，并定义了内存访问操作的可见性和有序性。
二、JMM中的关键概念
- 主内存与工作内存
在JMM中，每个线程都有自己的工作内存，工作内存保存了该线程使用到的变量的副本。所有变量存储在主内存中。线程不能直接操作主内存中的变量，必须通过工作内存来读写。 - volatile关键字
volatile变量直接存储在主内存中，线程对volatile变量的读写操作都会直接映射到主内存。这样保证了volatile变量的可见性，但不保证原子性。
package cn.juwatech.memory;
public class VolatileExample {
private volatile boolean flag = true;
public void stop() {
flag = false;
}
public void doWork() {
while (flag) {
// 执行任务
}
}
}- 原子性、可见性与有序性
- 原子性：保证操作不可被中断。
- 可见性：一个线程对变量的修改对其他线程是可见的。
- 有序性：操作按照程序的顺序执行。
三、同步机制
- synchronized关键字
synchronized保证了代码块的原子性和可见性。它通过锁机制来控制对共享资源的访问。
package cn.juwatech.sync;
public class SynchronizedExample {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}- Lock接口
Lock提供了更灵活的锁机制，相比于synchronized，Lock可以在不同范围内锁定，并且支持中断和超时等操作。
package cn.juwatech.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}四、volatile的使用场景
volatile适用于一些简单的状态标志，但不适合于需要原子性的操作。适合的场景包括：
- 状态标志
- 双重检查锁定单例模式
package cn.juwatech.singleton;
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}五、Java并发包中的高级工具
- CountDownLatch
用于同步一个或多个任务，强制它们等待由其他任务执行的一组操作完成。
package cn.juwatech.concurrent;
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(new Worker(latch)).start();
}
latch.await();
System.out.println("所有任务完成");
}
static class Worker implements Runnable {
private final CountDownLatch latch;
Worker(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
try {
// 执行任务
} finally {
latch.countDown();
}
}
}
}- CyclicBarrier
用于使一组线程互相等待，直到到达某个公共屏障点。
package cn.juwatech.concurrent;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
public static void main(String[] args) {
int parties = 3;
CyclicBarrier barrier = new CyclicBarrier(parties, () -> System.out.println("所有任务就绪"));
for (int i = 0; i < parties; i++) {
new Thread(new Task(barrier)).start();
}
}
static class Task implements Runnable {
private final CyclicBarrier barrier;
Task(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
// 执行任务
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
Thread.currentThread().interrupt();
}
}
}
}- Semaphore
信号量用于控制同时访问的线程数。
package cn.juwatech.concurrent;
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 10; i++) {
new Thread(new Task(semaphore)).start();
}
}
static class Task implements Runnable {
private final Semaphore semaphore;
Task(Semaphore semaphore) {
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
// 执行任务
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
semaphore.release();
}
}
}
}六、总结
深入理解Java内存模型及其在多线程编程中的应用是每个Java高级开发者必备的技能。通过合理使用volatile、synchronized、Lock以及Java并发包中的工具，可以有效地构建高效、安全的多线程应用程序。
