本文主要涉及lock和synchronized底层实现、特点、两者之间的差别、以及同步和锁部分的相关知识的补充解释。
一、lock的实现
lock的实现由java编写，和操作系统或JVM无关。lock主要通过CAS和AQS实现。
CAS：Compare And Swap，即比较交换
执行函数：CAS（V,E,N） V:要更新的变量 E:预期值 N:新值
原理图：
CAS操作没有锁，同样知道其他线程对共享资源操作影响，并执行相应的处理。CAS属于乐观派，允许再次尝试也允许失败的线程放弃操作。无锁操作免疫死锁。（CAS操作是系统原语，即原子指令，不会造成数据不一致问题），CAS操作的执行依赖于Unsafe类的方法，Unsafe类中的方法都直接调用操作系统底层资源执行任务。
AQS：AbstractQueuedSynchronizer，抽象的队列式同步器。
AQS会把所有的请求线程构成一个CLH队列，当一个线程执行完毕时，会激活自己的后继节点，执行中的进程不在队列中。等待执行的线程处于阻塞状态，线程的显示阻塞是通过调用LockSupport.park（）完成，LockSupport.park（）则调用sun.misc.Unsafe.park（）本地方法，再进一步，HotSpot（JVM技术实现）在linux中通过调用pthread_mutex_lock函数(线程调用该函数让互斥锁上锁，如果该互斥锁已被另一个线程锁定和拥有，则调用该线程将阻塞，直到该互斥锁变为可用为止)把线程交给系统内核进行阻塞。
CLH：自旋，先来先服务（FIFO）。是一种基于链表的可扩展、高性能、公平的自旋锁，线程仅在本地变量自旋，不断轮询前驱节点状态，发现前驱释放了锁就结束自旋。详细解析
加锁的实现（我们先以非公平锁进行分析）
1.通过代码可以很明显的看出它的不公平所在，当前线程会首先尝试获得锁而不是在队列中进行排队等候，这对于那些已经在队列中排队的线程来说显得不公平。当前进程通过CAS设置状态，设置成功，则直接获得锁，执行临界区代码。设置失败，则通过调用acquire函数进入同步队列。
static final class NonfairSync extends Sync {
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}2.acquire（1）函数。该方法主要由tryAcquire、addWaiter、acquireQueueud组成。下面则会详细介绍这几个方法。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}3.由NonfairSync函数可知，tryAcquire则是调用了nonfairTryAcquire方法。该方法首先判断当前状态，若c == 0则表示当前没有线程正在竞争该锁；若c！=0，说明有线程正拥有了该锁。当c==0时，通过CAS设置该状态的值为acquires，acquires的初始值为1，CAS设置成功，则认为当前线程获得了此锁。每次重入该锁，acquires会+1，每次unlock会-1，为0时释放锁；若c！=0，判断自己是否拥有锁，如果拥有锁只是简单的++acquires，并修改status值，没有竞争不用CAS（实现了偏向锁的功能）
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
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;
}4.addWaiter。addWaiter方法负责把当前无法获的锁的线程包装成一个Node，添加到队尾。其中参数mode是独占锁还是共享锁，默认为null，独占锁。追加到队尾的动作分两步：如果当前队尾已经存在(tail!=null)，则使用CAS把当前线程更新为Tail；如果当前Tail为null或则线程调用CAS设置队尾失败，则通过enq方法继续设置Tail。
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)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}enq方法。该方法就是循环调用CAS，即使有高并发的场景，无限循环将会最终成功把当前线程追加到队尾（或设置队头）。总而言之，addWaiter的目的就是通过CAS把当前线程追加到队尾，并返回包装后的Node实例。
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}5.acquireQueueud方法。该方法作用是对已经添加到队列的线程节点进行阻塞。在阻塞前再次调用一次tryAcquire，重试是否能获得锁，成功则直接返回，无需阻塞。parkAndCheckInterrupt会把当前线程挂起，从而阻塞住线程的调用栈。
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;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}shouldParkAfterFailedAcquire。当然也不是马上把请求不到锁的线程进行阻塞，还要检查该线程的状态，比如如果该线程处于Cancel状态则没有必要，具体的检查在shouldParkAfterFailedAcquire中。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}parkAndCheckInterrupt。LockSupport.park最终把线程交给系统（Linux）内核进行阻塞。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}到这里，加锁的操作已经完成。
解锁的实现
parkAndCheckInterrupt把线程挂起，只有当解锁时，线程才能执行以后的代码。
解锁代码相对简单，主要体现在AbstractQueuedSynchronizer.release和Sync.tryRelease方法中
1.release。调用tryRelease函数，若成功，则唤醒队列第一个线程（head）
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
} 2.tryRelease。tryRelease语义很明确：如果线程多次锁定，则进行多次释放，直至status==0则真正释放锁，所谓释放锁即设置status为0，因为无竞争所以没有使用CAS。
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
} 3.unparkSuccessor。这段代码的意思在于找出第一个可以unpark的线程，一般说来head.next == head，Head就是第一个线程，但Head.next可能被取消或被置为null，因此比较稳妥的办法是从后往前找第一个可用线程。貌似回溯会导致性能降低，其实这个发生的几率很小，所以不会有性能影响。之后便是通知系统内核继续该线程，在Linux下是通过pthread_mutex_unlock完成。之后，被解锁的线程进入上面所说的重新竞争状态。
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
} 二、synchronized的实现
此处需要了解一下对象头和monitor的相关内容。参考文章
synchronized是java内置的关键字，在JVM层面。synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。
JVM是通过进入、退出对象监视器（Monitor）来实现对方法、同步块的同步的。
1.实现对带代码块的同步
package com.paddx.test.concurrent;
public class SynchronizedDemo {
public void method() {
synchronized (this) {
System.out.println("Method 1 start");
}
}
}
每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.
3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
2.实现同步方法
package com.paddx.test.concurrent;
public class SynchronizedMethod {
public synchronized void method() {
System.out.println("Hello World!");
}
}
从反编译的结果来看，方法的同步并没有通过指令monitorenter和monitorexit来完成（理论上其实也可以通过这两条指令来实现），不过相对于普通方法，其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的：当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。
三、lock与synchronized的异同点
synchronized既可以加在方法上也可以加在特定代码块上；而lock需要显式的指定起始位置和终止位置；lock能完成synchronized的所有功能
1.synchronized是JVM层面的，是Java的关键字，托管给JVM执行；
lock由java代码实现的一个接口，比synchronized有更精确的线程语义。
2.synchronized在发生异常时，JVM会自动释放线程占有的锁，因此不会导致死锁的现象发生；
Lock如果没有主动通过unlock（）释放锁，很可能导致死锁现象，使用lock需要手动在finally块中释放锁。
3.使用synchronized，等待的线程会一直等待下去，不能响应中断；
Lock可以尝试获取锁，可以让等待锁的线程响应中断，线程可以不用一直等待下去。
4.synchronized无法判断锁的状态，不知道有没有成功获取锁；
Lock可以知道有没有成功获取锁。
5.synchronized：可重入，不可中断，非公平；
Lock：可重如，可中断，可公平。
6.性能：在竞争不激烈的情况下，synchronized性能优于Lock；
竞争激烈情况下，synchronized性能下降非常快。
面试题：
1.synchronized可重入是如何实现的：
每个锁关联一个线程持有者和计数器。当一个线程请求成功时，JVM会记下持有锁的线程，并将计数器设置为1，
当再有线程请求该锁时，如果请求的线程与持有锁线程一致，则再次拿到这个锁，并且计数器加一。当线程退出一个方法/块时，计数器会递减，计数器为0时，释放锁。
2.非公平锁和公平锁的实现过程：
非公平锁是只要当前线程CAS设置成功就表示当前线程获取了锁；而公平锁在CAS之前需要判断当前节点是否有前驱节点，如果有则需要等待前驱线程获取并释放锁之后才能继续获取锁。
扫一扫
4854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
