使用ReentrantLock两个方法的互斥访问

• 场景

现在有多个线程需要对两个方法都进行访问(一个方法名为test1，一个方法名为test2)，但是有个要求：

同一个时间只能两个方法互斥访问，而且两个方法可能在不同的类里面。就是多个线程只要有一个线程访问test1方法，那么其他线程test1和test2方法都不能访问，相反一样。

可能有人会想到synchronized关键字，但是如果两个方法是在同一个类中，这种办法能行得通，万一不在同一个类中，那用synchronized就没有任何意义。

当然可以用concurrent包里面的AtomicBoolean来作为锁关键字，略，这里就简单列个使用ReentrantLock代码：

    public static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        new Thread(){
            @Override
            public void run() {
                test1();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                test2();
            }
        }.start();
    }

    public static void test1(){
//        lock.lock();
        try {
            System.out.println("aaaaaaaa");
            Thread.sleep(4000);
            System.out.println("aaaaaaaa");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
//            lock.unlock();
        }
    }

    public static void test2(){
//        lock.lock();
        try {
            System.out.println("bbbbbbbb");
            Thread.sleep(2000);
            System.out.println("bbbbbbbb");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
//            lock.unlock();
        }
    }

当不使用lock的时候很明显test1和test2在同时执行：

aaaaaaaa
bbbbbbbb
bbbbbbbb
aaaaaaaa

Process finished with exit code 0

当使用lock的时候很明显test1和test2是互斥执行：

bbbbbbbb
bbbbbbbb
aaaaaaaa
aaaaaaaa

Process finished with exit code 0