并发学习笔记 (5)

摘要：执行会重新将设置为，并且通知唤醒其中一个若有的话在方法中调用了函数而处于等待状态的线程。除此之外，我们需要记录同一个线程重复对一个锁对象加锁的次数。竞争失败的线程处于就绪状态，长期竞争失败的线程就会饥饿。

tutorials site

  
Locks (and other more advanced synchronization mechanisms) are created using synchronized blocks, so it is not like we can get totally rid of the synchronized keyword.

  锁的实现是利用synchonized， wait()，notify()方法实现的。所以不可以认为锁可以完全脱离synchonized实现。

Java包 JUC java.util.concurrent.locks 包括了很多lock接口的实现了类，这些类足够使用。
但是需要知道如何使用它们，以及这些类背后的理论。JUC包教程

用synchonized：可以保证在同一时间只有一个线程可以执行 return ++count:

public class Counter{
  private int count = 0;

  public int inc(){
    synchronized(this){
      return ++count;
    }
  }
}

以下的Counter类用Lock代替synchronized 达到同样的目的：
lock() 方法会对 Lock 实例对象进行加锁，因此所有其他对该对象调用 lock() 方法的线程都会被阻塞，直到该 Lock 对象的 unlock() 方法被调用。

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类的简单实现：

javapublic class Lock{
  private boolean isLocked = false;

  public synchronized void lock() throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }

  public synchronized void unlock(){
    isLocked = false;
    notify();
  }
}

javapublic class Reentrant2{
    Lock lock = new Lock();

    public outer(){
        lock.lock();
        inner();
        lock.unlock();
    }

    public synchronized inner(){
        lock.lock();
        //do something
        lock.unlock();
    }
}

javapublic 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();
            }
        }
    }

    ...
}

 Starvation and Fairness 饥饿和公平

  
Java"s synchronized code blocks can be another cause of starvation.

  
每一个调用 lock() 的线程都会进入一个队列，当解锁后，只有队列里的第一个线程 （队首）被允许锁住 Fairlock 实例，所有其它的线程都将处于等待状态，直到他们处于队列头部。

    公平锁实现机制：为每一个线程创建一个专属锁对象（而非多个线程共享一个对象，来wait/notify()），然后用一个队列来管理这些锁对象，尝试加锁的线程会在各自的对象上等待，当一个线程unlock的时候，只通知队列头的锁对象，以唤醒其对应的线程

javapublic class FairLock {
    private boolean           isLocked       = false;
    private Thread            lockingThread  = null;
    private List waitingThreads =
            new ArrayList();

  public void lock() throws InterruptedException{
    QueueObject queueObject           = new QueueObject();
    boolean     isLockedForThisThread = true;
    synchronized(this){
        waitingThreads.add(queueObject);
    }

    while(isLockedForThisThread){
      synchronized(this){
        isLockedForThisThread =
            isLocked || waitingThreads.get(0) != queueObject;
        if(!isLockedForThisThread){
          isLocked = true;
           waitingThreads.remove(queueObject);
           lockingThread = Thread.currentThread();
           return;
         }
      }
      try{
        queueObject.doWait();
      }catch(InterruptedException e){
        synchronized(this) { waitingThreads.remove(queueObject); }
        throw e;
      }
    }
  }

  public synchronized void unlock(){
    if(this.lockingThread != Thread.currentThread()){
      throw new IllegalMonitorStateException(
        "Calling thread has not locked this lock");
    }
    isLocked      = false;
    lockingThread = null;
    if(waitingThreads.size() > 0){
      waitingThreads.get(0).doNotify();
    }
  }
}