Java中的线程同步全面讲解

// 同步方法
public synchronized void increment() {
    count++;
}

// 同步代码块
public void update() {
    synchronized(this) {
        // 临界区代码
    }
}

// 静态方法锁（类级别锁）
public static synchronized void staticMethod() {
    // ...
}

private final ReentrantLock lock = new ReentrantLock();

public void performTask() {
    lock.lock();  // 手动加锁
    try {
        // 临界区代码
    } finally {
        lock.unlock();  // 必须手动释放锁
    }
}

private AtomicInteger count = new AtomicInteger(0);

public void safeIncrement() {
    count.incrementAndGet();  // 原子操作
}

private volatile boolean running = true;

public void stop() {
    running = false;  // 写操作立即对其他线程可见
}

private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
private final Lock writeLock = rwLock.writeLock();

public String readData() {
    readLock.lock();
    try {
        return data;
    } finally {
        readLock.unlock();
    }
}

public void writeData(String value) {
    writeLock.lock();
    try {
        data = value;
    } finally {
        writeLock.unlock();
    }
}

private final Lock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();

public void put(Object item) throws InterruptedException {
    lock.lock();
    try {
        while (queue.isFull()) {
            notFull.await();  // 等待队列非满
        }
        queue.enqueue(item);
        notEmpty.signal();  // 唤醒等待的消费者
    } finally {
        lock.unlock();
    }
}

// 并发Map
Map<String, String> concurrentMap = new ConcurrentHashMap<>();

// 阻塞队列
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(100);

// 写时复制列表
List<String> safeList = new CopyOnWriteArrayList<>();

CountDownLatch latch = new CountDownLatch(3);

// 工作线程
void worker() {
    // 执行任务...
    latch.countDown();
}

// 主线程
latch.await();  // 阻塞直到计数归零
System.out.println("所有任务完成");

CyclicBarrier barrier = new CyclicBarrier(4, () -> 
    System.out.println("所有玩家准备就绪"));

void player() {
    prepare();
    barrier.await();  // 等待其他玩家
    startGame();
}

Semaphore semaphore = new Semaphore(5); // 5个许可证

void accessResource() {
    semaphore.acquire();  // 获取许可
    try {
        // 使用资源
    } finally {
        semaphore.release();  // 释放许可
    }
}

Exchanger<String> exchanger = new Exchanger<>();

// 线程A
String dataA = "Data from A";
String received = exchanger.exchange(dataA);

// 线程B
String dataB = "Data from B";
String received = exchanger.exchange(dataB);

// 1. 固定锁顺序
public void transfer(Account from, Account to, int amount) {
    Account first = from.id < to.id ? from : to;
    Account second = from.id < to.id ? to : from;
    
    synchronized(first) {
        synchronized(second) {
            // 转账操作
        }
    }
}

// 2. 尝试获取锁（带超时）
if (lock1.tryLock(1, TimeUnit.SECONDS)) {
    try {
        if (lock2.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // 操作
            } finally {
                lock2.unlock();
            }
        }
    } finally {
        lock1.unlock();
    }
}

// 3. 使用开放调用（避免在持有锁时调用外部方法）

// 锁消除（JIT编译器优化）
public String concat(String s1, String s2, String s3) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);  // 同步方法但可消除锁
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}

// 锁粗化（减少频繁加锁开销）
synchronized(lock) {
    operation1();
    operation2();
    operation3();
}

// 1. 生产者-消费者模式
BlockingQueue<Task> queue = new LinkedBlockingQueue<>();

// 2. 线程局部存储
private static ThreadLocal<SimpleDateFormat> dateFormat = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

// 3. Future模式
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> future = executor.submit(() -> computeExpensiveValue());
// ...其他操作
Integer result = future.get();

// 正确同步示例
class SafePublication {
    private int value;
    private volatile boolean initialized;
    
    public void initialize(int val) {
        value = val;
        initialized = true;  // volatile写
    }
    
    public int getValue() {
        if (initialized) {   // volatile读
            return value;
        }
        return -1;
    }
}

CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(data -> process(data))
    .thenAccept(result -> store(result))
    .exceptionally(ex -> handleError(ex));

private final StampedLock lock = new StampedLock();
private double balance;

public double readBalance() {
    long stamp = lock.tryOptimisticRead();  // 乐观读
    double currentBalance = balance;
    if (!lock.validate(stamp)) {  // 检查是否被修改
        stamp = lock.readLock();  // 退化为悲观读
        try {
            currentBalance = balance;
        } finally {
            lock.unlockRead(stamp);
        }
    }
    return currentBalance;
}

class AtomicCounter {
    private volatile int count;
    private static final VarHandle COUNT_HANDLE;
    
    static {
        try {
            COUNT_HANDLE = MethodHandles.lookup()
                .findVarHandle(AtomicCounter.class, "count", int.class);
        } catch (Exception e) {
            throw new Error(e);
        }
    }
    
    public void increment() {
        int current;
        do {
            current = (int) COUNT_HANDLE.getVolatile(this);
        } while (!COUNT_HANDLE.compareAndSet(this, current, current + 1));
    }
}

// 错误！字符串常量池导致意外共享锁
synchronized("LOCK") {
    // ...
}

class Account {
    private int balance;
    
    public synchronized void transfer(Account target, int amount) {
        this.balance -= amount;
        target.deposit(amount);  // 未同步！可能破坏不变性条件
    }
    
    public void deposit(int amount) {
        balance += amount;
    }
}

public class ThisEscape {
    public ThisEscape(EventSource source) {
        source.registerListener(  // 在构造完成前发布this引用
            new EventListener() {
                public void onEvent(Event e) {
                    doSomething(e);
                }
            });
    }
    
    void doSomething(Event e) { ... }
}