Java多线程实现之同步方法详解

class Counter {
    private int count = 0;
    
    public void increment() {
        count++; // 非原子操作，可能导致竞态条件
    }
    
    public int getCount() {
        return count;
    }
}

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++; // 线程安全的操作
    }
    
    public synchronized int getCount() {
        return count;
    }
}

class Counter {
    private int count = 0;
    private final Object lock = new Object(); // 锁对象
    
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
    
    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

class MyClass {
    private static int staticCount = 0;
    
    public static synchronized void incrementStatic() {
        staticCount++;
    }
}

class BankAccount {
    private double balance;
    
    public synchronized void deposit(double amount) {
        balance += amount;
    }
    
    public synchronized void withdraw(double amount) {
        balance -= amount;
    }
}

class DataContainer {
    private String data;
    private boolean isReady = false;
    
    public synchronized void setData(String data) {
        this.data = data;
        isReady = true;
        notifyAll(); // 通知等待的线程
    }
    
    public synchronized String getData() throws InterruptedException {
        while (!isReady) {
            wait(); // 等待数据准备好
        }
        return data;
    }
}

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // 执行操作
            }
        }
    }
    
    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // 执行操作
            }
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
}

public void process() {
    // 非关键代码
    
    synchronized (this) {
        // 关键代码，需要同步
    }
    
    // 非关键代码
}

private final Object lock = new Object();

public void method() {
    synchronized (lock) {
        // 同步代码
    }
}