ReentrantLock 重入锁(下)

    前沿:

      ReentrantLock 是java重入锁一种实现,在java中我们通常使用ReentrantLock 和 synchronized来实现锁功能，本篇通过例子来理解下ReentrantLock使用以及什么是可重入锁。

 理解可重入：

     1. 锁机制是为了多线程并发访问共享资源情况下为保证线程的安全，和对资源的原子性操作，

　　　　举个例子:

          i=i+1;其实是三部操作首先将i读取到线程的临时区存放，然后加一操作，最后将结果写回去。所谓锁机制就是保证一段程序在某段时间只有一个线程执行。

     2. 可重入性当一个线程获取锁的时候，后来的任务还可以继续获取锁，比其它线程有获取锁的优先性，解决问题，满足递归调用依然使锁机制有效。

       举个生活的例子：

         村里有一口井，每家都可以打水，但是，如果你正在打水的时候，你老弟来打水那么你老弟具有优先打水资格。

  简单小程序理解可重入锁：

    1. 重复获取锁: 

        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        System.out.println("Hello World1");
        reentrantLock.lock();
        System.out.println("Hello World2");
        reentrantLock.unlock();
        reentrantLock.unlock();
结果:

Hello World1
Hello World2

　2. 释放锁多一次

        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        System.out.println("Hello World1");
        reentrantLock.lock();
        System.out.println("Hello World2");
        reentrantLock.unlock();
        reentrantLock.unlock();
        reentrantLock.unlock();
结果:

Exception in thread "main" Hello World1
Hello World2
java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
at com.juxinli.docs.test.Main.main(Main.java:21)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

通过对比很明显发现同一个线程可以重复获取两次锁，但释放三次就出现异常。

3. 多线程锁机制

 

 ReentrantLock reentrantLock = new ReentrantLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    reentrantLock.lock();
                    System.out.println("Hello World1");
                    reentrantLock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                try {
                    Thread.sleep(1000);
                    System.out.println("Hello World2");
                    reentrantLock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
结果:

Hello World2
Hello World1

很明显按照逾期结果输出。