java同步访问不同的关键部分

Question

我有一个如下所示的方法。

public class CriticalSections
{

    public void mainMethod(boolean b)
        {
            if (b) {
                method1();
            }
            else {
                criticalMethod();
                method2();
            }
        }


        private void criticalMethod()
        {
            System.out.println("in criticalMethod");
        }

        private void method1()
        {
            System.out.println("in method1");
        }

        private void method2()
        {
            System.out.println("in method2");
        }
 }

我需要限制对这些方法的访问，以便

1. 当线程访问criticalMethod()时，应该限制所有其他线程对method1()和method2()的访问。类似地，当线程访问method1()和method2()时，访问criticalMethod() ) 应限制用于所有其他线程。
2. method1() 可以单独被不同的线程同时访问。
3. method2() 可以单独被不同的线程同时访问。
4. method1() 和 method2() 可以被不同的线程同时访问。

为了满足第一个访问条件，我想出了以下代码， 但这不会满足其他 3 个条件，因此性能会受到影响。

public class CriticalSections
{

    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();
    private final Lock lock3 = new ReentrantLock();

    public void mainMethod(boolean b)
    {
        if (b) {
            lock1.tryLock();
            try {
                method1();
            }
            finally {
                lock1.unlock();
            }
        }
        else {
            lock1.tryLock();
            try {
                lock2.tryLock();
                try {
                    lock3.tryLock();
                    try {
                        criticalMethod();
                    }
                    finally {
                        lock3.unlock();
                    }
                }
                finally {
                    lock2.unlock();
                }
            }
            finally {
                lock1.unlock();
            }
        }
        lock3.tryLock();
        try {
            method2();
        }
        finally {
            lock3.unlock();
        }
    }

    private void criticalMethod()
    {
        System.out.println("in criticalMethod");
    }

    private void method1()
    {
        System.out.println("in method1");
    }

    private void method2()
    {
        System.out.println("in method2");
    }
}

应该使用什么同步机制来满足上述场景？

Answer 1

您需要的是criticalMethod 上的排他锁和method1 和method2 方法上的可共享锁。实现这一点的最简单方法是使用java.util.concurrent.locks.ReentrantReadWriteLock，如下所示：

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

    public void mainMethod(boolean b) {
        if (b) {
            method1();
        } else {
            criticalMethod();
            method2();
        }
    }

    private void criticalMethod() {
        Lock writeLock = lock.writeLock();
        writeLock.lock();
        try {
            System.out.println("in criticalMethod");
        } finally {
            writeLock.unlock();
        }
    }

    private void method1() {
        Lock readLock = lock.readLock();
        readLock.lock();
        try {
            System.out.println("in method1");
        } finally {
            readLock.unlock();
        }
    }

    private void method2() {
        Lock readLock = lock.readLock();
        readLock.lock();
        try {
            System.out.println("in method2");
        } finally {
            readLock.unlock();
        }
    }
}

如果担心性能，也可以take a look atjava.util.concurrent.locks.StampedLock（Java 8+）。