多线程（三）：lock 关键字-CSDN博客

包括：

一. 为什么会出现 Lock

二. Lock 接口

三. ReentrantLock 可重入锁

四. ReadWriteLock 接口

一. 为什么会出现 Lock

如果一个代码被 synchronized 修饰，那么就意味着一个线程获得了对象的锁后，其他线程必须等待该线程释放锁，才能执行代码。那么，此时释放锁会有两种情况：

执行完代码，自动释放锁。
发生异常，JVM 让线程自动释放锁。

那么这时候问题就来了，如果一个线程获得了锁之后，阻塞了，此时又没有释放锁，那么其他线程只能等，那么这样就很影响效率了。

再举个例子：

读取文件如果读和写同时发生，那么会造成冲突，但是读和读是不会造成冲突的。如果我们用synchronized 关键字，那么会导致一个问题，当一个线程读的时候会获得锁，其他线程就没法读了，这样就很影响效率了。

最后，利用Lock 就可以解决以上的问题。

Lock可以让线程不用无限期的等待锁的释放。
又读锁和写锁，效率更高。
可以知道有没有成功获得锁。

二. Lock 接口

Lock 接口主要有 6个方法，如下：

public interface Lock {  
    void lock();  
    void lockInterruptibly() throws InterruptedException;  
    boolean tryLock();  
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  
    void unlock();  
    Condition newCondition();  
}

lock()：用来获得锁，如果锁被其他线程拿到，那么就等待。因为在异常的时候是不会自动释放锁，所以我们使用lock 的时候必须主动释放锁。一般我们使用lock() 都需要在 try{} catch{} 块中进行，并且将释放锁放在最后的finally 块中。以保证锁一定会被释放。一般使用如下形式：

Lock lock = ...;  
lock.lock();  
try{  
    //处理任务  
}catch(Exception ex){  
           
}finally{  
    lock.unlock();   //释放锁  
}

tryLock() 是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。一般tryLock() 可以如下用法：

Lock lock = ...;  
if(lock.tryLock()) {  
     try{  
         //处理任务  
     }catch(Exception ex){  
           
     }finally{  
         lock.unlock();   //释放锁  
     }   
}else {  
    //如果不能获取锁，则直接做其他事情  
}

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。因此lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {  
    lock.lockInterruptibly();  
    try {    
     //.....  
    }  
    finally {  
        lock.unlock();  
    }    
}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过 单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

三. ReentrantLock 可重入锁

ReentrantLock，意思是“可重入锁。举个例子来说明，当一个线程执行到 synchronized 方法的时候，比如说 method1 ，而在 method1 中调用了另外一个 synchronized 方法 method2，那么此时线程就不需要重新申请锁，而是可以直接执行方法method2。例如：

class MyClass {  
    public synchronized void method1() {  
        method2();  
    }  
       
    public synchronized void method2() {  
           
    }  
}

上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

举例说明可重入锁的应用，先说一个错误的例子：

    public class Test {  
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();  
        public static void main(String[] args)  {  
            final Test test = new Test();  
               
            new Thread(){  
                public void run() {  
                    test.insert(Thread.currentThread());  
                };  
            }.start();  
               
            new Thread(){  
                public void run() {  
                    test.insert(Thread.currentThread());  
                };  
            }.start();  
        }    
           
        public void insert(Thread thread) {  
            Lock lock = new ReentrantLock();    //注意这个地方  
            lock.lock();  
            try {  
                System.out.println(thread.getName()+"得到了锁");  
                for(int i=0;i<5;i++) {  
                    arrayList.add(i);  
                }  
            } catch (Exception e) {  
                // TODO: handle exception  
            }finally {  
                System.out.println(thread.getName()+"释放了锁");  
                lock.unlock();  
            }  
        }  
    }

对于上述的代码，其实还是会出现多线程问题。因为每次调用 insert(Thread thread) 的时候，都会创建一个新的 ReentrantLock，各个线程用各自的ReentrantLock，所以并不能达到锁的效果。更改如下：

    public class Test {  
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();  
        private Lock lock = new ReentrantLock();    //注意这个地方  
        public static void main(String[] args)  {  
            final Test test = new Test();  
               
            new Thread(){  
                public void run() {  
                    test.insert(Thread.currentThread());  
                };  
            }.start();  
               
            new Thread(){  
                public void run() {  
                    test.insert(Thread.currentThread());  
                };  
            }.start();  
        }    
           
        public void insert(Thread thread) {  
            lock.lock();  
            try {  
                System.out.println(thread.getName()+"得到了锁");  
                for(int i=0;i<5;i++) {  
                    arrayList.add(i);  
                }  
            } catch (Exception e) {  
                // TODO: handle exception  
            }finally {  
                System.out.println(thread.getName()+"释放了锁");  
                lock.unlock();  
            }  
        }  
    }

如上所示，所有线程都是利用公共的 ReentrantLock，所以能达到效果。

四 . ReadWriteLock 接口

ReadWriteLock 是一个接口，里面只定义了两个方法：

    public interface ReadWriteLock {  
        /** 
         * Returns the lock used for reading. 
         * 
         * @return the lock used for reading. 
         */  
        Lock readLock();  
       
        /** 
         * Returns the lock used for writing. 
         * 
         * @return the lock used for writing. 
         */  
        Lock writeLock();  
    }

一个用来获取读锁，一个用来获取写锁。 也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。

ReentrantReadWriteLock 类：

ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

    public class Test {  
        private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();  
           
        public static void main(String[] args)  {  
            final Test test = new Test();  
               
            new Thread(){  
                public void run() {  
                    test.get(Thread.currentThread());  
                };  
            }.start();  
               
            new Thread(){  
                public void run() {  
                    test.get(Thread.currentThread());  
                };  
            }.start();  
               
        }    
           
        public void get(Thread thread) {  
            rwl.readLock().lock();  
            try {  
                long start = System.currentTimeMillis();  
                   
                while(System.currentTimeMillis() - start <= 1) {  
                    System.out.println(thread.getName()+"正在进行读操作");  
                }  
                System.out.println(thread.getName()+"读操作完毕");  
            } finally {  
                rwl.readLock().unlock();  
            }  
        }  
    }

这样多个线程就可以同时进行读操作，大大提升了效率。如果一个或者多个线程占用了读锁，那么此时如果要申请写锁，则申请的写锁会一直等待释放锁。反之，如果申请了写锁，再申请读锁，也会一直等待。

最后，在性能上说，如果竞争资源不激烈，那么两者的性能是差不多的，但是有非常激烈的资源竞争，那么Lock 的性能要远远优于 synchronized。

Ps：

1. 可中断锁的概念：

synchronized 不是可中断锁，lock 是可中断锁。进一步举例说明：如果某个线程A 可以执行锁中的代码，另外一个 B 正在等待获取的锁，可能由于等待时间过长，此时 B 线程不想等了，想先处理其他事情，我们就可以中断该线程或者在别的线程中断它。比如说可以利用如上的组合：

void lockInterruptibly() throws InterruptedException;  
thread2.interrupt();

2. 公平锁：

公平锁也就是以请求锁的顺序来获取锁。非公平锁无法保证锁的获取是按照请求顺序来的，这样可能是导致某个或者一些线程永远获得不了锁。

在 Java 中， synchronized 就是非公平锁，它无法保证锁获得的顺序。对于可重入锁 ReentrantLock 和读写所 ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

总结：

Lock 比 Synchronized 的好处：1. lock 可以中止等待锁，synchronized不可以。2. lock 可以有读写锁，读线程可以真正的同步，synchronized不行。3.lock 可以知道有没有得到锁，synchronized 不知道。
Lock 接口：有6个方法。lock(),unlock()方法由于lock不会自动释放锁，所以我们必须放在 try -finally 块中；tryLock用于尝试能否获得锁；lockInterruptibly 用于中断线程对锁的等待。最后一个 newCondition 方法用于更细粒度的对并发进行控制。
ReentrantLock：可重入锁。也就是说有A，B两个方法，都用了 synchronized 修饰。A方法中调用B方法，那么我们调用A方法的时候，运行到B方法的时候，不需要重新申请锁。
ReadWriteLock：和Lock 是两个不同的根接口，ReentrantReadWriteLock 是实现 ReadWriteLock，而不是 Lock 接口。主要作用是可以让多个读线程同时的读资源。这样能够提高效率。
可中断锁：可以中止线程对锁的等待。synchronized 是非中断锁，Lock是可中断锁。
公平锁：按时间顺序获得锁。synchronized 是非公平锁。Lock默认也是非公平锁，但是可以设置为公平锁。