概论

一个线程获取了某个对象的锁，那么它可以再次获得此对象的锁。这个锁就叫做可重入锁。

synchronized就是可重入锁，示例：

public class LeaningThread {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Test()).start();
    }
}
class Test implements Runnable{
    @Override
    public void run() {
        synchronized (this){//第一次获取到锁
            while (true){
                synchronized (this){
                    System.out.println("第二次获取到了this对象的锁");
                }
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) { e.printStackTrace();}
            }
        }
    }
}

运行结果：

原理

在锁内部加一个计数器，若是同一个对象来获取则给予锁，并计数器加一。

手动实现：

public class LeaningThread {
    //ReentrantLock myLock = new ReentrantLock();
    MyLock myLock = new MyLock();

    void doSomething1() throws InterruptedException {
        System.out.println("1获得锁："+myLock.getHoldCount());
        myLock.lock();
        System.out.println("2获得锁："+myLock.getHoldCount());
        doSomething2();
        myLock.unlock();
        System.out.println("5获得锁："+myLock.getHoldCount());
    }
    void doSomething2() throws InterruptedException {
        //再次获取锁
        myLock.lock();
        System.out.println("3获得锁："+myLock.getHoldCount());
        myLock.unlock();
        System.out.println("4获得锁："+myLock.getHoldCount());
    }

    public static void main(String[] args) throws InterruptedException {
        LeaningThread lt =new LeaningThread();
        lt.doSomething1();
    }
}

class MyLock{
    private boolean isLocked = false;//锁是否被占用
    Thread lockedBy=null;//被谁锁了
    private int holdCount=0;//计数器，第几次获得锁
    //使用锁
    public synchronized void lock() throws InterruptedException {
        Thread temp=Thread.currentThread();
        while(isLocked&&lockedBy!=temp){//锁被占用，且不是被当前线程占用的时候，进入等待
            wait();
        }
        //锁没有被占用，或者是同一个线程来获取，获得锁
        isLocked = true;
        //记下这个线程
        lockedBy=temp;
        //第几次获得锁
        holdCount++;
    }
    //释放锁
    public synchronized void unlock() throws InterruptedException {
        if(Thread.currentThread()==lockedBy){
            holdCount--;//计数器减一
            if(holdCount==0){//最外层锁释放了
                isLocked = false;
                notify();
                lockedBy=null;
            }
        }
    }

    /**
     * 获取现在的第几层锁
     * @return
     */
    public int getHoldCount() {
        return holdCount;
    }
}

运行结果：

总结：

可重入锁是指同一个线程可以多次获取同一个对象的锁。实现是在锁内部加一个计数器，若是同一个对象来获取则给与锁，并计数器加一。

JDK中已经实现的一个可重入锁:Java.util.concurrent.locks.ReentrantLock。

 

原文地址：http://www.cnblogs.com/lurenjia-bky/p/16888064.html

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，请务用于商业用途! 3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！ 8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载 声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性