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

// 同步代碼塊
public void update() {
    synchronized(this) {
        // 臨界區(qū)代碼
    }
}

// 靜態(tài)方法鎖（類級別鎖）
public static synchronized void staticMethod() {
    // ...
}

private final ReentrantLock lock = new ReentrantLock();

public void performTask() {
    lock.lock();  // 手動加鎖
    try {
        // 臨界區(qū)代碼
    } 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();
    }
}

// 并發(fā)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() {
    // 執(zhí)行任務...
    latch.countDown();
}

// 主線程
latch.await();  // 阻塞直到計數(shù)歸零
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) {
            // 轉(zhuǎn)賬操作
        }
    }
}

// 2. 嘗試獲取鎖（帶超時）
if (lock1.tryLock(1, TimeUnit.SECONDS)) {
    try {
        if (lock2.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // 操作
            } finally {
                lock2.unlock();
            }
        }
    } finally {
        lock1.unlock();
    }
}

// 3. 使用開放調(diào)用（避免在持有鎖時調(diào)用外部方法）

// 鎖消除（JIT編譯器優(yōu)化）
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. 生產(chǎn)者-消費者模式
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(  // 在構(gòu)造完成前發(fā)布this引用
            new EventListener() {
                public void onEvent(Event e) {
                    doSomething(e);
                }
            });
    }
    
    void doSomething(Event e) { ... }
}