详解Java多线程与高并发(六)__ReentrantLock

ReentranLock重入锁类， 实现自Lock接口

推荐ReentrantLock，使用相对效率比synchronize高，因为量级较轻

使用重入锁，必须必须必须手工释放锁标记。一般都是在finally代码块中定义释放锁标记的unlock方法。

上代码

lock到unlock，相当于就是synchronize方法的开始到结束

public class Test_01 {
        Lock lock = new ReentrantLock();
        void m1(){
                try{
                        lock.lock(); // 相当于synchronize给对象加锁，这行以下一直到 lock.unlock()就被加锁了

                        for(int i = 0; i < 10; i++){
                                TimeUnit.SECONDS.sleep(1);
                                System.out.println("m1() method " + i);
                        }
                }catch(InterruptedException e){
                        e.printStackTrace();
                }finally{
                        lock.unlock(); // 解锁
                }
        }
        void m2(){
                lock.lock();
                System.out.println("m2() method");
                lock.unlock();
        }
        public static void main(String[] args) {
                final Test_01 t = new Test_01();
                new Thread(new Runnable() {
                        @Override
                        public void run() {
                                t.m1();
                        }
                }).start();
                try {
                        TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                new Thread(new Runnable() {
                        @Override
                        public void run() {
                                t.m2();
                        }
                }).start();
        }
}

尝试锁：

1、isLocked = lock.tryLock();

尝试锁， 如果有锁，无法获取锁标记(即加锁)，返回false。

如果获取锁标记，返回true(加锁成功)