目录
1、公平
2.非公平
3.独占锁
4.可重入
5.condition
1、公平
第一步:获取状态的 state 的值。如果 state=0 即代表锁没有被其它线程占用,执行第二步。如果 state!=0 则代表锁正在被其它线程占用,执行第三步。
第二步:判断队列中是否有线程在排队等待。如果不存在则直接将锁的所有者设置成当前线程,且更新状态 state 。如果存在就入队。
第三步:判断锁的所有者是不是当前线程。如果是则更新状态 state 的值。如果不是,线程进入队列排队等待。
2.非公平
第一步:获取状态的 state 的值。如果 state=0 即代表锁没有被其它线程占用,则设置当前锁的持有者为当前线程,该操作用 CAS 完成。如果不为0或者设置失败,代表锁被占用进行下一步。
此时获取 state 的值,如果是0,代表刚好线程释放了锁,此时将锁的持有者设为自己如果不是0,则查看线程持有者是不是自己如果是,则给state+1,获取锁如果不是,则进入队列等待
3.独占锁
AQS 在锁的获取时,并不一定只有一个线程才能持有这个锁,所以此时有了 独占模式和共享模式 的区别,我们本篇文章中的 ReentrantLock 使用的就是独占模式,在多线程的情况下只会有一个线程获取锁。
4.可重入
可重入锁就是当前持有锁的线程能够多次获取该锁,无需等待
AQS实现一个可重入锁
package com;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class MyLock implements Lock {
private Helper helper = new Helper();
private class Helper extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
// 第一个线程进来,可以获取锁
// 第二个线程进来,无法获取锁,返回false
Thread thread = Thread.currentThread();
// 判断是否为第一个线程进来
int state = getState();
if (state == 0) {
if (compareAndSetState(0, arg)) {// 如果当前状态值等于预期值,则以原子方式将同步状态设置为给定的更新值
// 设置当前线程
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
} else if(getExclusiveOwnerThread() == thread) { // 允许重入锁,当前线程和当前保存的线程是同一个线程
setState(state + 1);
return true;
}
return false;
}
/***
* 释放锁
此方法总是由正在执行释放的线程调用。
*/
@Override
protected boolean tryRelease(int arg) {
// 锁的获取和释放肯定是一一对应的,那么调用此方法的线程一定是当前线程
if (Thread.currentThread() != getExclusiveOwnerThread()) {
throw new RuntimeException();
}
boolean flag = false;
int state = getState() -arg;
if (state == 0) {// 当前锁的状态正确
setExclusiveOwnerThread(null);
flag = true;
}
setState(state);
return flag;
}
protected Condition newCondition() {
return new ConditionObject();
}
}
@Override
public void lock() {
// 独占锁
helper.acquire(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
// 可中断
helper.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return helper.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return helper.tryAcquireNanos(1, unit.toNanos(time));
}
@Override
public void unlock() {
helper.release(1);
}
@Override
public Condition newCondition() {
return helper.newCondition();
}
}
5.condition
在Java并发编程中,每个Java堆中的对象在“出生”的时刻都会“伴生”一个监视器对象,而每个Java对象都会有一组监视器方法:wait()、notify()以及notifyAll()。我们可以通过这些方法实现Java多线程之间的协作和通信,也就是等待唤醒机制,如常见的生产者-消费者模型。但是关于Java对象的这组监视器方法我们在使用过程中,是需要配合synchronized关键字才能使用,因为实际上Java对象的等待唤醒机制是基于monitor监视器对象实现的。与synchronized关键字的等待唤醒机制相比,Condition则更为灵活,因为synchronized的notify()只能随机唤醒等待锁的一个线程,而Condition则可以更加细粒度的精准唤醒等待锁的某个线程。与synchronized的等待唤醒机制不同的是,在monitor监视器模型上,一个对象拥有一个同步队列和一个等待队列,而AQS中一个锁对象拥有一个同步队列和多个等待队列。对象监视器Monitor锁实现原理如下: