锁

从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。

synchronized与Lock对比

1、如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2）线程执行发生异常，此时JVM会让线程自动释放锁。

那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能等待，影响程序执行效率。

2、当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。

但是采用synchronized关键字来实现同步的话，就会导致一个问题：

如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

3、另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。

注意：

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

2）Lock必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

synchronized 就不是可中断锁，而 Lock 是可中断锁。如果某一线程 A 正在执行锁中的代码，另一线程 B 正在等待获取该锁，可能由于等待时间过长，线程 B 不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

java.util.concurrent.locks包常用的类

1、    Lock

在Lock中声明了四个方法来获取锁，lock()、tryLock()、tryLock(longtime, TimeUnit unit)和lockInterruptibly()。

unLock()方法是用来释放锁的。

lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。释放锁的操作放在finally块中进行，以保证锁一定被被释放

Lock lock = ...;

lock.lock();

try{

    //处理任务

}catch(Exception ex){

    

}finally{

    lock.unlock();   //释放锁}

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

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

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。

public void method() throwsInterruptedException {

   lock.lockInterruptibly();

    try { 

     //.....

    }

    finally {

       lock.unlock();

}}

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

因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

2、    ReentrantLock可重入锁

可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性基于线程的分配，而不是基于方法调用的分配。例如，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

注意：锁是对象级别的，如果不同的线程，同时访问一个对象的不同的同步方法，仍然需要等待，同步执行，因为当一个线程获取该对象的锁时，其他线程虽然是其他的方法，但是只要是这个对象的，就需要等待第一个线程执行完成之后才能执行。

    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();

        }}

这样输出为：

Thread-0得到了锁

Thread-1得到了锁

Thread-0释放了锁

Thread-1释放了锁

原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会实例化新的对象，只需要将lock声明为类的属性即可：

public class Test {

    private Lock lock = new ReentrantLock();    //注意这个地方

    public static voidmain(String[] args)  {

        ...

    }      

    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();

        }

    }}

3、    ReadWriteLock

public interface ReadWriteLock{

     Lock readLock();

     Lock writeLock();}

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

4、    ReentrantReadWriteLock

假如有多个线程要同时进行读操作的话，synchronized直到thread1执行完读操作之后，才会打印thread2执行读操作的信息。

public class Test {

    private ReentrantReadWriteLock rwl = newReentrantReadWriteLock();

    

    public static voidmain(String[] args)  {

      ...

    }      

    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();

        }}}

而改成用读写锁的话，thread1和thread2在同时进行读操作。这样就大大提升了读操作的效率。不过要注意的是，占用了读锁，其他线程如果要申请写锁，需要等待释放读锁。占用了写锁，其他线程如果申请写锁或者读锁，需要等待释放写锁。