Java中Synchronized的适用场景

在Java中，synchronized关键字主要用于解决多线程并发访问共享资源时的同步问题。以下是一些适用synchronized关键字的场景：

1. 单例模式：确保一个类只有一个实例，并提供一个全局访问点。在单例模式的实现中，可以使用synchronized关键字来保证实例化过程的线程安全。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 修改共享数据：当多个线程需要修改共享数据时，使用synchronized关键字可以确保同一时间只有一个线程能够修改数据，从而避免数据不一致的问题。

public class SharedData {
    private int data;

    public synchronized void increment() {
        data++;
    }

    public synchronized void decrement() {
        data--;
    }

    public synchronized int getData() {
        return data;
    }
}

3. 读写操作：当多个线程需要对共享数据进行读写操作时，可以使用synchronized关键字来确保数据的一致性。在这种情况下，可以使用读写锁（ReentrantReadWriteLock）来提高性能。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class SharedData {
    private int data;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void write(int newData) {
        lock.writeLock().lock();
        try {
            data = newData;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int read() {
        lock.readLock().lock();
        try {
            return data;
        } finally {
            lock.readLock().unlock();
        }
    }
}

4. 线程间协作：当多个线程需要相互等待对方完成某个操作时，可以使用synchronized关键字结合wait()和notify()方法来实现线程间的协作。

public class ProducerConsumer {
    private final Object lock = new Object();
    private boolean isProduced = false;

    public void produce() throws InterruptedException {
        synchronized (lock) {
            while (isProduced) {
                lock.wait();
            }
            // 生产数据
            isProduced = true;
            lock.notify();
        }
    }

    public void consume() throws InterruptedException {
        synchronized (lock) {
            while (!isProduced) {
                lock.wait();
            }
            // 消费数据
            isProduced = false;
            lock.notify();
        }
    }
}

需要注意的是，过度使用synchronized关键字可能导致性能下降和死锁等问题。在实际应用中，应根据具体需求选择合适的同步策略。