详解Java中的ReentrantLock锁

reentrantlock锁

reentrantlock是java中常用的锁，属于乐观锁类型，多线程并发情况下。能保证共享数据安全性，线程间有序性
reentrantlock通过原子操作和阻塞实现锁原理，一般使用lock获取锁，unlock释放锁，
下面说一下锁的基本使用和底层基本实现原理，lock和unlock底层

lock的时候可能被其他线程获得所，那么此线程会阻塞自己，关键原理底层用到unsafe类的api: cas和park

使用

java.util.concurrent.locks.reentrantlock类

在多线程环境下使用，创建锁对象，调用lock()获取锁开始处理逻辑，处理完unlock()释放锁。注意使用的时候lock和unlock必须成对出现，不然可能出现死锁或者严重堵塞的情况

unlock

//创建锁对象
reentrantlock lock = new reentrantlock();
lock.lock(); //获取锁（锁定）
system.out.println("一段需要上锁的代码")
lock.unlock(); //锁释放

执行完代码后，释放锁，让其他线程去获取，需要注意的是，多个线程使用的锁对象必须是同一个。

什么情况需要上锁，就是在多线程不安全的情况下，多个线程操作同一个对象。
如多个线程同时操作一个队列，offer()添加对象，两个线程同时offer，因为不是原子操作，很可能一个线程添加成功，另一个线程添加失败，延伸到一些业务中是要杜绝的问题。

可以用锁解决问题，我们可以定义一个队列同一时间只能被一个拿到锁的线程操作，即保证offer这种非原子操作完成后，释放锁，再让其他线程拿到锁后，才能offer，保证有序的offer，不会丢失信息。

示例

为了体现锁的作用，这里sleep睡眠0.1秒，增加哪个线程获取锁的随机性
因为线程唤醒后，会开始尝试获取锁，多个线程下竞争一把锁是随机的

package javabasis.threads;
import java.util.concurrent.locks.reentrantlock;

public class locktest implements runnable {
  
	public static reentrantlock lock = new reentrantlock();//创建锁对象
	private int thold;
  
	public locktest(int h) {
		this.thold = h;
	}
	
	public static void main(string[] args) {
		for (int i = 10; i < 15; i++) {
			new thread(new locktest(i),"name-" + i).start();
		}
	}

	@override
	public void run() {
		try {
			thread.sleep(100);
			lock.lock(); //获取锁
			system.out.println("lock threadname:" + thread.currentthread().getname());
			{
				system.out.print(" writestart ");
				for (int i = 0; i < 15; i++) {
						thread.sleep(100);
					system.out.print(thold+",");
				}
				system.out.println(" writeend");
			}
			system.out.println("unlock threadname:" + thread.currentthread().getname() + "\r\n");
			lock.unlock(); //锁释放 
		} catch (interruptedexception e) {	
		}		
	}	
}

运行main方法输出结果：

lock threadname:name-10
 writestart 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, writeend
unlock threadname:name-10

lock threadname:name-14
 writestart 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14, writeend
unlock threadname:name-14

lock threadname:name-13
 writestart 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13, writeend
unlock threadname:name-13

lock threadname:name-11
 writestart 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, writeend
unlock threadname:name-11

lock threadname:name-12
 writestart 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12, writeend
unlock threadname:name-12

这体现在多线程情况下，锁能做到让线程之间有序运行，

如果没有锁，情况可能是 12,13,13,10,10,10,12，没有锁其他线程可能插队执行system.out.print

将上锁的代码注释后输出结果：

lock threadname:name-11
lock threadname:name-12
 writestart lock threadname:name-10
 writestart lock threadname:name-13
 writestart lock threadname:name-14
 writestart writestart 14,12,10,11,13,11,12,14,10,13,10,13,14,12,11,10,14,12,11,13,14,11,13,12,10,13,10,12,14,11,11,13,10,12,14,14,10,12,11,13,11,14,13,12,10,14,10,11,13,12,14,12,11,13,10,14,10,11,12,13,12,14,11,13,10,11,10,14,13,12,11, writeend
unlock threadname:name-11

13,12, writeend
unlock threadname:name-12

 writeend
unlock threadname:name-13

14, writeend
unlock threadname:name-14

10, writeend
unlock threadname:name-10

原理

reentrantlock主要用到unsafe的cas和park两个功能实现锁（cas + park ）

多个线程同时操作一个数n，使用原子（cas）操作，原子操作能保证同一时间只能被一个线程修改，而修改数n成功后，返回true，其他线程修改失败，返回false，
这个原子操作可以定义线程是否拿到锁，返回true代表获取锁，返回false代表为没有拿到锁。

拿到锁的线程，自然是继续执行后续逻辑代码，而没有拿到锁的线程，则调用park，将线程（自己）阻塞。

线程阻塞需要其他线程唤醒，reentrantlock中用到了链表用于存放等待或者阻塞的线程，每次线程阻塞，先将自己的线程信息放入链表尾部，再阻塞自己；之后需要拿到锁的线程，在调用unlock 释放锁时，从链表中获取阻塞线程，调用unpark 唤醒指定线程

unsafe

sun.misc.unsafe是关键类，提供大量偏底层的api 包括cas park
sun.misc.unsafe 此类在openjdk中可以查看

cas 原子操作

compare and swapz(cas)比较并交换，是原子性操作，
原理：当修改一个(内存中的)变量o的值n的时候，首先有个期望值expected，和一个更新值x，先比较n是否等于expected，等于，那么更新内存中的值为x值，否则不更新。

public final native boolean compareandswapint(object o, long offset,
                       int expected,
                       int x);

这里offset据了解，是对象的成员变量在内存中的偏移地址，
即底层一个对象object存放在内存中，读取的地址是0x2110，此对象的一个成员变量state的值也在内存中，但内存地址肯定不是0x2110

java中的cas使用

java.util.concurrent.locks.abstractqueuedsynchronizer 类

private static final unsafe unsafe = unsafe.getunsafe();
private static final long stateoffset;
static {
    try {
      stateoffset = unsafe.objectfieldoffset
        (abstractqueuedsynchronizer.class.getdeclaredfield("state")); //获取成员变量state在内存中的偏移量

    } catch (exception ex) { throw new error(ex); }
  }
protected final boolean compareandsetstate(int expect, int update) {
    // see below for intrinsics setup to support this
    return unsafe.compareandswapint(this, stateoffset, expect, update);
  }

在java中，compareandsetstate这个操作如果更新成功，返回true,失败返回false，通过这个机制，可以定义锁（乐观锁）。
如三个线程a，b，c，在目标值为0的情况下，同时执行compareandsetstate(0,1) 去修改它
期望值是0，更新值是1，因为是原子操作，在第一个线程操作成功之后目标值变为1，返回true
所以另外两个线程就因为期望值为0不等于1，返回false。
我们可以理解为，返回true的线程拿到了锁。

最终调用的java类是sun.misc.unsafe

park 阻塞

java中可以通过unsafe.park()去阻塞（停止）一个线程，也可以通过unsafe.unpark()让一个阻塞线程恢复继续执行

unsafe.park()

阻塞(停止)当前线程

public native void park(boolean isabsolute, long time); 

根据debug测试，此方法能停止线程自己，最后通过其他线程唤醒

unsafe.unpark()

取消阻塞(唤醒)线程

public native void unpark(object thread);

根据debug测试，此方法可以唤醒其他被park调用阻塞的线程

park与interrupt的区别

interrupt是thread类的的api，park是unsafe类的api，两者是有区别的。
测试了解，thread.currentthread().interrupt(),线程会继续运行，而unsafe.park(thread.currentthread())就是直接阻塞线程，不继续运行代码。

获取锁

线程cas操作失败，可以park阻塞自己，让其他拥有锁的线程在unlock的时候释放自己，达到锁的效果

java.util.concurrent.locks.reentrantlock的lock方法是

public void lock() {
    sync.lock();
  }

而sync的实现类其中一个是java.util.concurrent.locks.reentrantlock.nonfairsync 不公平锁，它的逻辑比较直接

/**
nonfairsync
*/
final void lock() {
  if (compareandsetstate(0, 1))//cas操作，如果true 则表示操作成功，获取锁
    setexclusiveownerthread(thread.currentthread()); //设置获取锁拥有者为当前线程
  else
    acquire(1);//获取锁失败，锁住线程(自己)
}

获取失败后阻塞线程

如果获取锁失败，会再尝试一次，失败后，将线程（自己）阻塞

public final void acquire(int arg) {
    if (!tryacquire(arg) &&
      acquirequeued(addwaiter(node.exclusive), arg))
      selfinterrupt();
  }
protected final boolean tryacquire(int acquires) {
      return nonfairtryacquire(acquires);
    }
final boolean nonfairtryacquire(int acquires) {
      final thread current = thread.currentthread();
      int c = getstate();
      if (c == 0) { 
			//如果期望值为0，内存值也为0，再次尝试获取锁（此时其他线程也可能尝试获取锁）
        if (compareandsetstate(0, acquires)) {
          setexclusiveownerthread(current); //第二次获取成功，放回true
          return true;
        }
      }
      else if (current == getexclusiveownerthread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
          throw new error("maximum lock count exceeded");
        setstate(nextc);
        return true;
      }
      return false; //没有获取到锁，返回false，则 !tryacquire(arg) 为true，执行acquirequeued(addwaiter(node.exclusive), arg)
    }

获取锁失败，线程会进入循环，acquirequeued 方法中for是个无限循环，除非获取锁成功后，才会return。

//获取锁失败后，准备阻塞线程（自己）
//阻塞之前，添加节点存放到链表，其他线程可以通过这个链表唤醒此线程
private node addwaiter(node mode) {
    node node = new node(thread.currentthread(), mode); 
    // try the fast path of enq; backup to full enq on failure
    node pred = tail;
    if (pred != null) {
      node.prev = pred;
      if (compareandsettail(pred, node)) {//cas操作
        pred.next = node;
        return node;
      }
    }
    enq(node);
    return node;
  }

// 在此方法直到获取锁成功才会跳出循环
final boolean acquirequeued(final node node, int arg) {
    boolean failed = true;
    try {
      boolean interrupted = false;
      for (;;) {
        final node p = node.predecessor();
        if (p == head && tryacquire(arg)) {
          sethead(node);
          p.next = null; // help gc
          failed = false;
          return interrupted; //获取锁成功之后才会return跳出此方法
        }
        if (shouldparkafterfailedacquire(p, node) && //如果满足阻塞条件
          parkandcheckinterrupt()) 
          interrupted = true;
      }
    } finally {
      if (failed)
        cancelacquire(node);
    }
  }

  private final boolean parkandcheckinterrupt() {
    locksupport.park(this);//停止线程（自己）
    return thread.interrupted();
  }

释放锁

一个线程拿到锁之后，执行完关键代码，必须unlock释放锁的，否则其他线程永远拿不到锁

public void unlock() {
    sync.release(1);
  }

public final boolean release(int arg) {
    if (tryrelease(arg)) {
      node h = head;
      if (h != null && h.waitstatus != 0)
        unparksuccessor(h);
      return true;
    }
    return false;
  }
//java.util.concurrent.locks.reentrantlock.sync 的tryrelease
 protected final boolean tryrelease(int releases) {
      int c = getstate() - releases; //这里一般是 1 - 1 = 0
      if (thread.currentthread() != getexclusiveownerthread()) //只能是锁的拥有者释放锁
        throw new illegalmonitorstateexception();
      boolean free = false;
      if (c == 0) {
        free = true;
        setexclusiveownerthread(null);
      }
      setstate(c); //设置state为0，相当于释放锁，让其他线程compareandsetstate(0, 1)可能成功
			
      return free;
    }

protected final void setstate(int newstate) {
    state = newstate; //没有cas操作
  }

setstate不做cas操作是因为，只有拥有锁的线程才调用unlock，不存才并发混乱问题

其他线程没拿到锁不会设值成功，其他线程在此线程设置state为0之前，compareandsetstate(0, 1)都会失败，拿不到锁，此线程设置state为0之后，其他线程compareandsetstate(0, 1)才有可能成功，返回true从而拿到锁

释放线程

线程在获取锁失败后，有可能阻塞线程（自己），在阻塞之前把阻塞线程信息放入链表的
释放锁之后，线程会尝试通过链表释放其他线程（一个），让一个阻塞线程恢复运行

阻塞线程被取消阻塞后如何拿到锁(reentrantlock中)

有时候线程被中断后，唤醒继续执行后面的代码，
线程没有拿到锁之后主动阻塞自己的，但所还没拿到，被唤醒之后怎么去尝试重新获取锁呢？ 里面有一个for循环

final void lock() {
      if (compareandsetstate(0, 1)) 
        setexclusiveownerthread(thread.currentthread());//拿到锁
      else
        acquire(1); //没有拿到锁
    }
// 上锁失败，会添加一个节点，节点包含线程信息，将此节点放入队列
public final void acquire(int arg) {
    if (!tryacquire(arg) &&
      acquirequeued(addwaiter(node.exclusive), arg))
      selfinterrupt();
  }

// 存好节点后，将线程（自己）中断，等其他线程唤醒（自己）
final boolean acquirequeued(final node node, int arg) {
    boolean failed = true;
    try {
      boolean interrupted = false;
      for (;;) {//循环 被唤醒后线程还是在此处循环
        
        final node p = node.predecessor();
        if (p == head && tryacquire(arg)) {//尝试获取锁
          sethead(node);
          p.next = null; // help gc
          failed = false;
          return interrupted; //如果拿到锁了，才会return
        }
        if (shouldparkafterfailedacquire(p, node) &&
          parkandcheckinterrupt()) //没拿到锁时，主动中断thread.currentthread()
          interrupted = true;
      }
    } finally {
      if (failed)
        cancelacquire(node);
    }
  }

被唤醒后继续执行compareandsetstate(0, 1)返回false没拿到锁，则继续循环或阻塞

compareandsetstate(0, 1) 这个操作是获取锁的关键

以上就是详解java中的reentrantlock锁的详细内容，更多关于java中的reentrantlock锁的资料请关注其它相关文章！