ReentrantLock -入门

ReentrantLock 是什么

　　重入锁，是一个可以在持有相同锁的执行代码之间进行互斥的锁。具有与使用synchronized 方法和语句时同样的基本行为和语义，但是功能更多，也更加灵活。一个ReentrantLock 由一个线程调用lock方法获取，如果锁没有被另外一个线程锁定。当前线程成功将锁获取并锁定，且没有解锁，那么方法将返回true。如果当前线程已经获取到该锁，调用lock方法，将立即返回true。

ReentrantLock 跟synchronized 区别

　　两者都是阻塞式同步锁，当一个线程占用锁后，其他线程无法进入被锁定的代码块。区别是：ReentrantLock 在使用的时候，必须创建lock对象。必须在开始部分写lock语句，结束部分写unlock语句。如果没有手工释放，会导致死锁。同样，ReentrantLock的锁粒度要比synchronized要细，也更加灵活。

ReentrantLock  基本方法

　　lock-unLock，基本的加锁解锁实现，如果锁没有被另外一个线程占用则立即返回true，如果当前线程本身已经持有该锁定，则保持计数增加1，返回true。如果锁被其他线程保持，则当前线程阻塞，在获取到 锁之前一直处于休眠状态。代码如下：

    Lock lock = new ReentrantLock();
    
    void m1() {
        try  {
            lock.lock();
            for (int i = 0; i < 10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    void m2() {
        try {
            lock.lock();
            System.out.println("m2.....");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        T02_ReentrantLock2 rl = new T02_ReentrantLock2();
        new Thread(rl::m1).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(rl::m2).start();
    }
    

　　trylock，当lock方法执行的时候，如果获取不到锁，线程就会阻塞。trylock方法可以在不阻塞线程的情况下，尝试获取锁。如果没有被其他线程保持锁定，那么当前线程获取锁定，并返回true。如果锁由另一个线程持有，则该方法将立即返回值为false 。trylock方法还有一个多态的方法，可以传入一个超时时间，在超时结束之前未获取到锁，将会等待。超时结束仍然未获取到锁，将会返回false。代码如下：

    Lock lock = new ReentrantLock();

    void m1() {
        try {
            lock.lock();
            for (int i = 0; i < 10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 可以使用trylock对代码进行尝试锁定，不管锁定与否，方法都将继续执行，
     * 可以根据tryLock的返回值来确定锁定，也可以指定tryLock的时间，超时后抛出异常，
     */
    void m2() {
        /*
         * boolean locked = lock.tryLock();
         * System.out.println("m2....."+locked);
         * if(locked) locked.unlock();
         */
        boolean locked = false;
        
        try {
            locked = lock.tryLock(5,TimeUnit.SECONDS);
            
            System.out.println("m2....."+locked);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(locked)lock.unlock();
        }
    }

    public static void main(String[] args) {
        T02_ReentrantLock3 rl = new T02_ReentrantLock3();
        new Thread(rl::m1).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(rl::m2).start();
    }

　　lockInterruptibly

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("t1开始执行");
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                System.out.println("t1执行结束");
            } catch (InterruptedException e) {
                System.out.println("interruped");
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            System.out.println("t2 开始执行");
            boolean isLock =false;
            try {
                try {
                    lock.lockInterruptibly(); // 可以对interrup()方法做出响应
                    isLock = true;
                } catch (Exception e) {
                    e.printStackTrace();
                    isLock = false;
                }
                System.out.println("t2 获取锁");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2 end");
            
            } finally {
                if (isLock) {
                    lock.unlock();
                }
            }
        });
        t2.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e3) {
            e3.printStackTrace();
        }

        t2.interrupt();// 打断线程2的等待

    }

　　公平锁

　　公平锁，在线程获取锁的时候，执行一定的公平策略。线程先申请锁，就会先获取锁，但是不能保证线程在执行的时候也是公平的。代码如下：

    private static ReentrantLock lock = new ReentrantLock(true);// 参数为true的时候，表示为公平锁，等在前面的先执行

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "执行了");
            }  finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        T02_ReentrantLock5 rl = new T02_ReentrantLock5();
        Thread t1 = new Thread(rl);
        Thread t2 = new Thread(rl);
        t1.start();
        t2.start();

    }

　　分组唤醒

　　synchronized在线程wait时，如果唤醒，需要将所有当前锁下的线程全部唤醒，而ReentrantLock提供了一个分组唤醒的功能。通过 newCondition方法创建一个分组，然后通过分组.await()方法进行分组等待。通过分组.signalAll() 方法进行分组唤醒。现在用一个生产者消费者的案例进行说明：

{
    final private   LinkedList<T> lists = new LinkedList<>();
    final  private int MAX = 10;
    private volatile int count = 0;
    private Lock lock = new ReentrantLock();
    // 生产者
    private Condition producer = lock.newCondition();
    // 消费者
    private Condition conSumer = lock.newCondition();

    public void put(T t){
        try {
            lock.lock();
            while (count==MAX){
                System.out.println("队列已满，生产者等待");
                producer.await();
                System.out.println("生产者被唤醒");
            }
            lists.add(t);
            ++count;
            System.out.println("加入对象，当前队列数量为"+count);
            conSumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public  T get(){
        T t= null;
        try {
            lock.lock();
            while (count == 0) {
                System.out.println("消费者等待");
                conSumer.await();
                System.out.println("消费者被唤醒");
            }
            t= lists.getFirst();
            --count;
            System.out.println("消费，当前队列数量为"+count);
            System.out.println("消费者执行");
            producer.signalAll();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        return t;
    }

    public static void main(String[] args) {
        MyContainer1 qu= new MyContainer1();
        for (int i = 0; i < 10; i++) {
        new Thread(()->{
           while (true){
                qu.put(new Object());
            }
            }).start();
        }
        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                while (true){
                    qu.get();
                }
            }).start();
        }
    }


}