java如何数据同步
数据同步方法
使用 synchronized 关键字
synchronized 是 Java 中最基本的数据同步机制，可以修饰方法或代码块，确保同一时间只有一个线程可以访问被保护的资源。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}使用 volatile 关键字
volatile 保证变量的可见性，当一个线程修改了 volatile 变量，其他线程能立即看到最新值。
public class SharedObject {
private volatile boolean flag = false;
public void setFlag(boolean value) {
flag = value;
}
}使用 Lock 接口
Java 并发包中的 Lock 接口提供了比 synchronized 更灵活的锁机制，如 ReentrantLock。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}使用原子类
Java 并发包中的原子类（如 AtomicInteger）提供原子操作，无需显式同步。
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
}使用并发集合
Java 并发包提供线程安全的集合类，如 ConcurrentHashMap。
import java.util.concurrent.ConcurrentHashMap;
public class Cache {
private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
public void put(String key, String value) {
map.put(key, value);
}
}使用 CountDownLatch
CountDownLatch 允许一个或多个线程等待其他线程完成操作。
import java.util.concurrent.CountDownLatch;
public class Worker implements Runnable {
private final CountDownLatch latch;
public Worker(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
// 执行任务
latch.countDown();
}
}使用 CyclicBarrier
CyclicBarrier 让一组线程互相等待，达到某个公共屏障点后再继续执行。
import java.util.concurrent.CyclicBarrier;
public class Task implements Runnable {
private final CyclicBarrier barrier;
public Task(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
// 执行任务
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}使用 Semaphore
Semaphore 控制同时访问特定资源的线程数量。
import java.util.concurrent.Semaphore;
public class Pool {
private Semaphore semaphore = new Semaphore(5);
public void accessResource() {
try {
semaphore.acquire();
// 访问资源
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}
}
