多线程（三）---Lock

一、Lock的基本介绍

   1.Lock本身是一个接口，接口中含有四个抽象方，且不是Java内置的。

   2.分别是lock()，unlock()，trylock()以及lockInterruptibly()｛下方有详细介绍｝。

   3.Lock是一个操作麻烦（对比Synchronized来说），但是功能强大的锁。

   lock的源码：

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

     透过源码我们可以看到Lock本身是一个包含有四个抽象方法的接口。

二、Synchronized的优点与缺点

      Synchronized的优点：操作比较简单不需要手动释放锁，自带异常处理机制。

      Synchronized的缺点：Synchronized功能单一，无法做比较细节的操作。Synchronized采用悲观锁机制，在保护了安全的同时，牺牲了效率。

三、Lock的四种方法

      1.因为Lock只是一个接口，而实现了Lock接口的类只有ReentrantLock。所以我们通过子类向上传递的方式得到Lock。

      1.lock()：

               lock本身只是单纯的一个锁，当调用lock（）时，如果资源处于被释放状态，则线程锁住该资源；否则线程进入等待状态等候资源的被释放。值的注意的是，Lock本身不具备异常机制，所以我们需要自行作出异常处理机制。

public class LockTest {
    static Lock lock = new ReentrantLock();
    public static void main(String[]args){
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        LockTest.instert(Thread.currentThread());
                    }
                }
        ).start();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        LockTest.instert(Thread.currentThread());
                    }
                }
        ).start();
    }

    public static void instert(Thread thread){
        lock.lock();
        try{
            System.out.println(Thread.currentThread()+":获取了锁");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println(Thread.currentThread()+":释放了锁");
            lock.unlock();   
        }
    }

}

      2.unlock():

          当调用该方法时，会释放当下资源。与Synchronized不同，Lock是需要手动调用方法来释放锁的（很重要），不然将陷入死锁状态。所以我们常常在异常处理中的finally模块来调用unlock（）。

      3.trylock():

          线程尝试获取资源，如果可以获得该资源，则会返回true，否则会返回false；trylock的重载方法中，可以设置时间以及时间格式来完成在一段时间内尝试获取资源，如果有则返回true，否则返回false；

这是使用trylock方法：

public class LockTest {
    static Lock lock = new ReentrantLock();
    public static void main(String[]args) {
        new Thread (
                new Runnable() {
                    @Override
                    public void run(){
                        LockTest.instert(Thread.currentThread());
                    }
                }
        ).start();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        LockTest.instert(Thread.currentThread());
                    }
                }
        ).start();
    }

    public static void instert(Thread thread){
        if(lock.tryLock()) {
            try {
                System.out.println(Thread.currentThread() + ":获取了锁");
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread() + ":释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println(Thread.currentThread()+":没能获得锁");
        }
    }

}

trylock带参数的实现：由于带参方法作出了InterrupedException，所以调用该方法的方法都应该抛出该异常，但是重写的Run方法无法抛出异常所以需要手动在run中调用trycatch方式抛出异常

public class LockTest {
    static Lock lock = new ReentrantLock();
    public static void main(String[]args) {
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        try{
                            LockTest.instert(Thread.currentThread());
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
        ).start();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        try{
                            LockTest.instert(Thread.currentThread());
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
        ).start();
    }

    public static void instert(Thread thread) throws InterruptedException{
        if(lock.tryLock((long)2000,TimeUnit.MILLISECONDS)){
            try {
                System.out.println(Thread.currentThread() + ":获取了锁");
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread() + ":释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println(Thread.currentThread()+":没能获得锁");
        }
    }

}

4.lockInterruptibly():

         lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

        这就是Lock锁的可中断性，是Synchronized不具备的：

public class LockTest {
    static Lock lock = new ReentrantLock();
    public static void main(String[]args) {
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        try{
                            LockTest.instert(Thread.currentThread());
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
        ).start();
        Thread thread1 = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        try{
                            LockTest.instert(Thread.currentThread());
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
        );
        thread1.start();
        thread1.interrupt();
        System.out.println(thread1.isAlive());

    }

    public static void instert(Thread thread) throws InterruptedException{

//        if(lock.tryLock((long)2000,TimeUnit.MILLISECONDS)){          //2000毫秒的尝试
//        if(lock.tryLock()){        //trylock尝试一次
//      lock.lock();          //调用锁方法
          lock.lockInterruptibly();
            try {
                System.out.println(Thread.currentThread() + ":获取了锁");
                Thread.sleep(10000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println(Thread.currentThread() + ":释放了锁");
                lock.unlock();
            }
//        }else{
//            System.out.println(Thread.currentThread()+":没能获得锁");
//        }
    }

}

四、ReadWriteLock类：

        这个类也是一个接口，该接口只定义了writeLock与readLock两个抽象方法，而且这两个方法最后都会返回一个Lock。源码如下：

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

   调用ReentrantReadWriteLock中readLock会返回ReentrantReadWriteLock.ReadLock类，该类中依然拥有trylock,lock,newCondition,unlock等方法。

   调用ReentrantReadWriteLock中readLock会返回ReentrantwriteWriteLock.WriteLock类，该类中依然拥有trylock,lock,newCondition,unlock等方法。

   当两个都是读取时，锁允许多个线程使用，有一个是写线程时，则进入的线程会锁住。

public class ReadWrite {
    static ReentrantReadWriteLock rl =new ReentrantReadWriteLock();
    public static void main(String[]args){
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        ReadWrite.insert(Thread.currentThread());
                    }
                }
        ).start();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        ReadWrite.insert(Thread.currentThread());
                    }
                }
        ).start();

    }
    public static void insert(Thread thread1){
         rl.writeLock().lock();
//         rl.readLock().lock();
        try{
            long start = System.currentTimeMillis();
            while(System.currentTimeMillis()-start<=300) {
                System.out.println(Thread.currentThread().getName() + "正在进行写操作");
                Thread.sleep(10);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rl.writeLock().unlock();
//            rl.readLock().unlock();
            System.out.println((Thread.currentThread()+"：已经结束了写操作"));
        }
    }

}