Java中的锁详解说明

下文笔者讲述java中锁的详解，如下所示:

java锁简介

锁与synchronized同步块具有同样的功能:是一种线程同步机制
但锁比Java中的synchronized同步块更复杂
------------------------------------------------------------------------------------------
因为锁是由synchronized同步块的方式实现的

一个简单的锁简介说明

public class Counter{
    private int count = 0;
    public int inc(){
        synchronized(this){
            return ++count;
        }
    }
}

以上的代码中使用了synchronized(this)代码块
可保证在同一时间只有一个线程可运行return ++count
下文将使用Lock代替synchronized达到了同样的目的

public class Counter{
    private Lock lock = new Lock();
    private int count = 0;
    public int inc(){
        lock.lock();
        int newCount = ++count;
        lock.unlock();
        return newCount;
    }
}

lock()方法会对Lock实例对象进行加锁
因此所有对该对象调用lock()方法的线程都会被阻塞
直到该Lock对象的unlock()方法被调用

Lock类的实现

public class Counter{
public class Lock{
    private boolean isLocked = false;
    public synchronized void lock()
        throws InterruptedException{
        while(isLocked){
            wait();
        }
        isLocked = true;
    }

    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}
--------代码中的 
 while(isLocked)循环,称之为“自旋锁”

当isLocked为true时，调用lock()的线程在wait()调用上阻塞等待
为防止该线程没有收到notify()调用也从wait()中返回(也称作虚假唤醒),
这个线程会重新去检查isLocked条件以决定当前是否可以安全地继续执行还是需要重新保持等待,
而不是认为线程被唤醒了就可以安全地继续执行了
当isLocked为false，当前线程会退出while(isLocked)循环，并将isLocked设回true,让其它正在调用lock()方法的线程能够在Lock实例上加锁

当线程运行完毕临界区(lock()和unlock()之间)的代码后,会调用unlock()
运行unlock()会重新将isLocked设置为false
并且通知(唤醒)其中一个(若有的话)在lock()方法中调用了wait()函数而处于等待状态的线程。

锁的可重入性

Java中的synchronized同步块是可重入的
这意味着如果一个java线程进入了代码中的synchronized同步块
并因此获得了该同步块使用的同步对象对应的管程上的锁
那么这个线程可以进入由同一个管程对象所同步的另一个java代码块

public class Reentrant{
    public synchronized fun1(){
        fun2();
    }

    public synchronized fun2(){
        //
    }
}

此处的fun1()和fun2()都被声明为synchronized,
Java中和synchronized(this)块等效
当一个线程调用了fun1()
在fun1()里调用fun2()就没有什么问题
因为这两个方法（代码块）都由同一个管程对象("this")所同步

下面的代码为不可重入锁

public class Reentrant2{
    Lock lock = new Lock();
    public outer(){
        lock.lock();
        inner();
        lock.unlock();
    }

    public synchronized inner(){
        lock.lock();
        //业务代码
        lock.unlock();
    }
}
/*
运行outer()的线程首先会锁住Lock实例,当继续调用inner()。inner()方法中该线程将再一次尝试锁住Lock实例,此时该操作会失败（也就是说该线程会被阻塞）,
因为这个Lock实例已经在outer()方法中被锁住了
由于两次lock()之间没有调用unlock(),第二次调用lock就会阻塞
*/
 
/*Lock类可重入性的调整示例分享*/

public class Lock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;

    public synchronized void lock()
        throws InterruptedException{
        Thread callingThread =Thread.currentThread();
        while(isLocked && lockedBy != callingThread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = callingThread;
  }

    public synchronized void unlock(){
        if(Thread.curentThread() == this.lockedBy){
            lockedCount--;

            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }
}

以上代码中的while循环(自旋锁)已经考虑到已锁住该Lock实例的线程
当同一个线程重复对一个锁对象加锁的次数
当unlock时,则减少锁定的次数，直到锁次数为零时，则解锁