Synchronized和Lock
synchronized是一个关键字, Lock是一个接口, 对应有多种实现. 使用synchronized进行同步和使用Lock进行同步的区别
- 使用synchronized同步时, 未获得锁的进程只能等待. 而使用Lock进行同步时, 有多种选择: 例如用读写锁区分不同的同步需求, 用tryLock使未获得锁的线程立即返回或在一段时间后返回, 或者在等待时可以随时响应中断后返回.
- 使用synchronized无法知道线程是否成功获取到锁, 使用Lock可以
- synchronized不需要手动释放锁, 在代码块执行结束或发生异常时, jvm会让线程自动释放锁. 而Lock需要手动释放锁, 如果有未释放的情况, 就会出现死锁.
Spin Lock
自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。自旋锁适用于锁保护的临界区很小的情况，临界区很小的话，锁占用的时间就很短。
public class Spinlock {
private AtomicReference<Thread> owner = new AtomicReference<>();
private void lock() {
Thread current = Thread.currentThread();
while (!owner.compareAndSet(null, current)) {
}
}
private void unlock() {
Thread current = Thread.currentThread();
owner.compareAndSet(current, null);
}
}
Ticket Spin Lock
为了解决Spin Lock中随机不公平的问题, 使用排队自旋锁
public class TicketSpinlock {
private AtomicInteger ticket = new AtomicInteger();
private AtomicInteger inService = new AtomicInteger();
public int lock() {
int myTicket = ticket.getAndIncrement();
while (myTicket != inService.get()) {
}
return myTicket;
}
// 只有持有锁的才能释放锁
public void unlock(int ticket) {
int next = ticket + 1;
inService.compareAndSet(ticket, next);
}
}
MCS Spin Lock
MCS锁是基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，直接前驱负责通知其结束自旋, 减少不必要的处理器缓存同步的次数，降低总线和内存的开销.
public class McsSpinlock {
public static class McsNode {
volatile McsNode next;
volatile boolean isBlock = true; // 默认是在等待锁
}
volatile McsNode queue;// 指向最后一个申请锁的MCSNode
private static final AtomicReferenceFieldUpdater<McsSpinlock, McsNode> UPDATER =
AtomicReferenceFieldUpdater.newUpdater(McsSpinlock.class, McsNode.class, "queue");
public void lock(McsNode currentThread) {
McsNode predecessor = UPDATER.getAndSet(this, currentThread);// step 1
if (predecessor != null) {
predecessor.next = currentThread;// step 2
while (currentThread.isBlock) {// step 3
}
} else { // 只有一个线程在使用锁，没有前驱来通知它，所以得自己标记自己为非阻塞
currentThread.isBlock = false;
}
}
public void unlock(McsNode currentThread) {
if (currentThread.isBlock) {// 锁拥有者进行释放锁才有意义
return;
}
if (currentThread.next == null) {// 检查是否有人排在自己后面
if (UPDATER.compareAndSet(this, currentThread, null)) {// step 4
// compareAndSet返回true表示确实没有人排在自己后面
return;
} else {
// 突然有人排在自己后面了，可能还不知道是谁，下面是等待后续者
// 这里之所以要忙等是因为：step 1执行完后，step 2可能还没执行完
while (currentThread.next == null) { // step 5
}
}
}
currentThread.next.isBlock = false;
currentThread.next = null;// for GC
}
}
CLH Spin Lock
基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。
public class ClhSpinlock {
public static class ClhNode {
private volatile boolean isLocked = true; // 默认在等待
}
private volatile ClhNode tail ;
private static final AtomicReferenceFieldUpdater<ClhSpinlock, ClhNode> UPDATER =
AtomicReferenceFieldUpdater. newUpdater(ClhSpinlock.class, ClhNode.class , "tail" );
public void lock(ClhNode currentThread) {
ClhNode preNode = UPDATER.getAndSet( this, currentThread);
if(preNode != null) {//已有线程占用了锁，进入自旋
while(preNode.isLocked ) {
}
}
}
public void unlock(ClhNode currentThread) {
// 如果队列里只有当前线程，则释放对当前线程的引用（for GC）。
if (!UPDATER .compareAndSet(this, currentThread, null)) {
// 还有后续线程
currentThread. isLocked = false ;// 改变状态，让后续线程结束自旋
}
}
}
JDK Locks: ReentrantLock
JDK的concurrent.locks包下的ReentrantLock, 用于实现响应中断的非阻塞锁, 里面模仿CLH Lock的机制, 实现了公平队列和非公平队列. 官方文档里使用了一个互相鞠躬的例子来举例ReentrantLock的使用
public class Safelock {
static class Friend {
private final String name;
private final Lock lock = new ReentrantLock();
public Friend(String name) {this.name = name;}
public String getName() {return this.name;}
public boolean impendingBow(Friend bower) {
// 非阻塞, 当两个锁都拿到时, 才bowback
Boolean myLock = false;
Boolean yourLock = false;
try {
myLock = lock.tryLock();
yourLock = bower.lock.tryLock();
} finally {
if (!(myLock && yourLock)) {
// 此步拿到的锁, 不用了要立即释放
if (myLock) {
lock.unlock();
}
if (yourLock) {
bower.lock.unlock();
}
}
}
return myLock && yourLock;
}
public void bow(Friend bower) {
if (impendingBow(bower)) {
try {
System.out.format("%s: %s has bowed to me!%n", bower.getName(), this.name);
bower.bowBack(this);
} finally {
// 用完后及时释放锁
lock.unlock();
bower.lock.unlock();
}
} else {
System.out.format(
"%s: %s wanted to bow to me, but saw that I was bowing.%n",
bower.getName(), this.name);
}
}
public void bowBack(Friend bower) {
System.out.format("%s: %s has bowed back to me!%n", bower.getName(), this.name);
}
}
static class BowLoop implements Runnable {
private Friend bower;
private Friend bowee;
public BowLoop(Friend bower, Friend bowee) {
this.bower = bower;
this.bowee = bowee;
}
public void run() {
Random random = new Random();
for (; ; ) {
try {
Thread.sleep(random.nextInt(10));
} catch (InterruptedException e) {}
bowee.bow(bower);
}
}
}
public static void main(String[] args) {
final Friend alphonse =
new Friend("Alphonse");
final Friend gaston =
new Friend("Gaston");
final Friend hudson =
new Friend("Hudson");
new Thread(new BowLoop(alphonse, hudson)).start();
new Thread(new BowLoop(hudson, gaston)).start();
new Thread(new BowLoop(gaston, alphonse)).start();
}
}