java synchronize怎样避免锁膨胀

在Java中，synchronized关键字用于控制多个线程对共享资源的访问，以实现线程同步。然而，当多个线程长时间持有同一个锁时，可能会导致锁膨胀，从而影响系统性能。为了避免锁膨胀，可以采取以下策略：

1. 使用细粒度锁：尽量使用细粒度的锁，例如对不同的资源使用不同的锁对象。这样可以减少线程持有锁的时间，从而降低锁膨胀的风险。

class FineGrainedLock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            // ...
        }
    }

    public void method2() {
        synchronized (lock2) {
            // ...
        }
    }
}

2. 使用读写锁：对于读多写少的场景，可以使用读写锁（如ReentrantReadWriteLock）来替代synchronized关键字。读写锁允许多个线程同时读取共享资源，而只允许一个线程写入。这样可以减少线程持有锁的时间，从而降低锁膨胀的风险。

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

class ReadWriteLockExample {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        lock.readLock().lock();
        try {
            // ...
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        lock.writeLock().lock();
        try {
            // ...
        } finally {
            lock.writeLock().unlock();
        }
    }
}

3. 使用无锁编程：无锁编程是一种通过原子操作（如CAS）来实现线程同步的方法。无锁编程可以避免使用锁，从而降低锁膨胀的风险。然而，无锁编程通常比使用锁更复杂，需要更高的编程技巧。

import java.util.concurrent.atomic.AtomicInteger;

class LockFreeExample {
    private final AtomicInteger counter = new AtomicInteger(0);

    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = counter.get();
            newValue = oldValue + 1;
        } while (!counter.compareAndSet(oldValue, newValue));
    }
}

4. 使用线程局部变量：对于某些场景，可以使用线程局部变量（如ThreadLocal）来避免共享资源。线程局部变量是每个线程都有自己的副本，因此不需要使用锁来同步访问。

class ThreadLocalExample {
    private static final ThreadLocal threadLocalCounter = new ThreadLocal<>();

    public void increment() {
        int currentValue = threadLocalCounter.getOrDefault(0, 0);
        threadLocalCounter.set(currentValue + 1);
    }
}

总之，避免锁膨胀的关键是减少线程持有锁的时间。通过使用细粒度锁、读写锁、无锁编程和线程局部变量等方法，可以有效地降低锁膨胀的风险。