在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<Integer> threadLocalCounter = new ThreadLocal<>();

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

總之，避免鎖膨脹的關鍵是減少線程持有鎖的時間。通過使用細粒度鎖、讀寫鎖、無鎖編程和線程局部變量等方法，可以有效地降低鎖膨脹的風險。