java中的lock

拼搏现实的明天。 2022-08-20 03:22 126阅读 0赞

lock就像同步块一样是一种线程同步机制，除此之外locks要比java的同步块更加复杂。locks（和其他的更加先进的同步机制）是使用同步块创建的，所以我们完全摆脱synchronize关键字是不可能的。从java5开始，java.util.concurrent.locks包含了几种lock的实现，所以你或许不必实现自己的locks，但是，你依然要知道怎么样使用它们，知道他们背后的实现原理也是非常有帮助的，要想得到更多的细节，可以看一下java.util.concureent.locks.lock接口

### 一个简单的lock ###

我们以一个java的同步块代码开始

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

注意inc()方法中的synchronized(this)块，这个块确保在某一时刻只能有一个线程执行return ++count这个操作。在同步块中的代码可以更好，但是这个++count操作足够了解了。

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

这个Counter类可以写成如下的方式，使用lock替代同步块lock()方法锁住了Lock实例以至于所有调用lock方法的线程都会阻塞直到unlock方法执行。

下边这是一个简单的lock的实现

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)循环，也叫作“旋转锁”。旋转锁和方法wait以及notify在线程信号这篇文章中多次讲到了。当isLocked为true的时候，线程调用lock方法在wait方法调用中等待。在这种情况相下没有收到notify调用的时候线程从wait调用中返回的是不确定的，线程要重新检查isLocked条件来看看继续是否是安全的，而不仅仅是假设条件安全的。如果isLocked是假的，线程会退出循环并且设置isLocked为true，为其他线程调用lock方法锁定Lock实例。当线程在关键区完成工作的时候（在lock和unlock之间的代码），线程调用unlock方法，执行unlock方法把isLocked设置回假，叫醒在wait方法中的等待的线程。

### Lock Reentrance ###

java中的同步块是再入的。也就是说，如果一个java线程进入了一个同步代码块，在监控对象上拿到了同步锁并进入同步状态，线程可以其他的java代码块，在相同的监视对象上进行同步。下边这是一个例子

public class Reentrant{
    
      public synchronized outer(){
        inner();
      }
    
      public synchronized inner(){
        //do something
      }
    }

注意outer方法和inner方法都声明为同步的，在java中和synchronized(this)是等价的。如果线程调用了outer方法毫无疑问它会调用内部的inner方法。因为两个方法或者是块在同一个监视对象（this）上进行的同步，如果一个线程已经拥有了这个监视对象的锁，它可以访问同一个监视对象上的所有的同步代码块，这就叫做重入，线程可以重新进入已经拥有锁的任何的代码块。

早前看到的实现并不是重入，如果我们像下边这样重写Reentrant类，线程调用outer会在inner方法中的lock.lock中阻塞。

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

一个线程调用outer方法会首先锁上Lock实例，然后调用inner方法。在inner方法中线程再一次的想锁住锁实例，这会失败（意思是线程将会被阻塞），因为锁实例已经在outer方法中被锁住了。线程将会被第二次阻塞的原因是它调用了lock方法而没有调用unlock犯法，我们看看这个lock方法的实现之后就很明显了

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

注意while循环现在把锁实例也考虑进去了，或者锁被解锁调用线程是锁实例。在while循环中的条件决定是否线程要退出，当前情况下isLocked必须是false才可以，而不管线程是否已经锁住它了。为了让锁类重入，我们需要做一些小小的改变

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循环现在把锁实例也考虑进去了，或者锁被解锁调用线程是锁实例

翻译的不好，还有一些没有翻译出来，想看原文的同学可以看下边的链接

原文地址：http://tutorials.jenkov.com/java-concurrency/locks.html