显示锁和AQS及其原理
显示锁
Lock和Synchronized：优先使用Synchronized关键字，除非需要获取锁可以被中断，超时获取锁，尝试获取锁的功能
公平锁和非公平锁：如果在时间上，先对锁获取的请求，一定先被满足，这个锁是公平的，不满足就是非公平的，非公平锁一般效率更高
读写锁（ReadWriteLock）：Lock和Synchronized都是排它锁，而读写锁同一时刻允许多个读线程同时访问，但是写线程访问的时候，所有的读和写都被阻塞，最适用于读多写少的情况
public class GoodsInfo {
private final String name;
private double totalMoney;//总销售额
private int storeNumber;//库存数
public GoodsInfo(String name, int totalMoney, int storeNumber) {
this.name = name;
this.totalMoney = totalMoney;
this.storeNumber = storeNumber;
}
public double getTotalMoney() {
return totalMoney;
}
public int getStoreNumber() {
return storeNumber;
}
public void changeNumber(int sellNumber){
this.totalMoney += sellNumber*25;
this.storeNumber -= sellNumber;
}
}
【使用读写锁】：
public interface GoodsService {
public GoodsInfo getNum();//获得商品的信息
public void setNum(int number);//设置商品的数量
}
public class UseRwLock implements GoodsService {
private GoodsInfo goodsInfo;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock getLock = lock.readLock();//读锁
private final Lock setLock = lock.writeLock();//写锁
public UseRwLock(GoodsInfo goodsInfo) {
this.goodsInfo = goodsInfo;
}
@Override
public GoodsInfo getNum() {
getLock.lock();
try {
SleepTools.ms(5);
return this.goodsInfo;
}finally {
getLock.unlock();
}
}
@Override
public void setNum(int number) {
setLock.lock();
try {
SleepTools.ms(5);
goodsInfo.changeNumber(number);
}finally {
setLock.unlock();
}
}
}
【主函数】 ：
public class BusiApp {
static final int readWriteRatio = 10;//读写线程的比例
static final int minthreadCount = 3;//最少线程数
//static CountDownLatch latch= new CountDownLatch(1);
//读操作
private static class GetThread implements Runnable{
private GoodsService goodsService;
public GetThread(GoodsService goodsService) {
this.goodsService = goodsService;
}
@Override
public void run() {
// try {
// latch.await();//让读写线程同时运行
// } catch (InterruptedException e) {
// }
long start = System.currentTimeMillis();
for(int i=0;i<100;i++){//操作100次
goodsService.getNum();
}
System.out.println(Thread.currentThread().getName()+"读取商品数据耗时："
+(System.currentTimeMillis()-start)+"ms");
}
}
//写操做
private static class SetThread implements Runnable{
private GoodsService goodsService;
public SetThread(GoodsService goodsService) {
this.goodsService = goodsService;
}
@Override
public void run() {
// try {
// latch.await();//让读写线程同时运行
// } catch (InterruptedException e) {
// }
long start = System.currentTimeMillis();
Random r = new Random();
for(int i=0;i<10;i++){//操作10次
SleepTools.ms(50);
goodsService.setNum(r.nextInt(10));
}
System.out.println(Thread.currentThread().getName()
+"写商品数据耗时："+(System.currentTimeMillis()-start)+"ms---------");
}
}
public static void main(String[] args) throws InterruptedException {
GoodsInfo goodsInfo = new GoodsInfo("Cup",100000,10000);
GoodsService goodsService = new UseRwLock(goodsInfo);
for(int i = 0;i<minthreadCount;i++){
Thread setT = new Thread(new SetThread(goodsService));
for(int j=0;j<readWriteRatio;j++) {
Thread getT = new Thread(new GetThread(goodsService));
getT.start();
}
SleepTools.ms(100);
setT.start();
}
//latch.countDown();
}
}
【执行结果】：
Thread-0写商品数据耗时：610ms---------
Thread-4读取商品数据耗时：764ms
Thread-9读取商品数据耗时：763ms
Thread-5读取商品数据耗时：764ms
Thread-8读取商品数据耗时：764ms
Thread-6读取商品数据耗时：768ms
Thread-7读取商品数据耗时：768ms
Thread-10读取商品数据耗时：768ms
Thread-3读取商品数据耗时：774ms
Thread-2读取商品数据耗时：774ms
Thread-1读取商品数据耗时：782ms
Thread-11写商品数据耗时：608ms---------
Thread-17读取商品数据耗时：773ms
Thread-16读取商品数据耗时：773ms
Thread-20读取商品数据耗时：779ms
Thread-21读取商品数据耗时：779ms
Thread-12读取商品数据耗时：779ms
Thread-13读取商品数据耗时：785ms
Thread-18读取商品数据耗时：782ms
Thread-14读取商品数据耗时：782ms
Thread-19读取商品数据耗时：782ms
Thread-15读取商品数据耗时：788ms
Thread-22写商品数据耗时：602ms---------
Thread-31读取商品数据耗时：774ms
Thread-24读取商品数据耗时：775ms
Thread-32读取商品数据耗时：774ms
Thread-29读取商品数据耗时：775ms
Thread-25读取商品数据耗时：775ms
Thread-27读取商品数据耗时：775ms
Thread-23读取商品数据耗时：775ms
Thread-30读取商品数据耗时：775ms
Thread-28读取商品数据耗时：775ms
Thread-26读取商品数据耗时：775ms
在读多写少的情况下优先使用【读写锁】
ReentrantReadWriteLock
AQS
AbstractQueuedSynchronized 继承AQS，使用模板方法设计模式
-
模板方法：
- 独占式获取锁：
acquire，acquireInterruptibly，tryAcquireNanos - 独占式释放锁：
release - 共享式获取锁：
acquireShared，acquireSharedInterruptibly，tryAcquireSharedNanos - 共享式释放锁：
releaseShared
- 独占式获取锁：
-
需要子类实现的流程方法：
- 独占式获取锁：
tryAcquire - 独占式释放锁：
tryRelease - 共享式获取锁：
tryAcquireShared - 共享式释放锁：
tryReleaseShared isHeldExclusively：判断同步器是否处于独占模式
- 独占式获取锁：
同步状态state：
getState：获取当前同步状态setState：设置当前同步状态compareAndSetState：使用CAS设置状态，保证状态设置的原子性
ReentrantLock、ReentrantReadWriteLock、CountDownLatch、Semaphore、ThreadPoolExector内部都是使用AQS实现的
【使用AQS实现自己的锁】：
public class SelfLock implements Lock{
//state 表示获取到锁 state=1 获取到了锁，state=0，表示这个锁当前没有线程拿到
private static class Sync extends AbstractQueuedSynchronizer{
//是否占用
protected boolean isHeldExclusively() {
return getState()==1;
}
protected boolean tryAcquire(int arg) {
if(compareAndSetState(0,1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int arg) {
if(getState()==0) {
throw new UnsupportedOperationException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
Condition newCondition() {
return new ConditionObject();
}
}
private final Sync sycn = new Sync();
@Override
public void lock() {
sycn.acquire(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
sycn.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return sycn.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return sycn.tryAcquireNanos(1, unit.toNanos(time));
}
@Override
public void unlock() {
sycn.release(1);
}
@Override
public Condition newCondition() {
return sycn.newCondition();
}
}
AQS数据结构
【节点和同步队列】：争夺锁失败的线程就会打包成Node放到同步队列里
Node里waitStatus状态：
CANCELLED：线程等待超时后者被中断了，需要从队列中移走SIGNAL：后续节点等待状态，当前节点，通知后面的节点去运行CONDITION：当前节点处于等待队列PROPAGATE：共享，表示状态要往后面节点传播0：表示初始状态
节点在同步队列中的增加和移出：
争夺锁的有可能是多个节点，因此新增节点到尾部要使用CAS设置
而一个队列的首节点有且仅有一个，因此删除首节点不需要使用CAS
独占式同步状态获取与释放
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;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
【Condition分析】: 一个Condition内部维护了一个 等待队列，所有调用condition.await方法的线程会加入到等待队列中，并且线程状态转换为等待状态，等待队列是一个单向队列
我们可以多次调用lock.newCondition()方法创建多个condition对象，也就是一个lock可以持有多个等待队列
Condition等待队列中节点的移动：
await方法：调用condition.await()方法后会使得当前获取lock的线程（也就是当前线程是同步队列中的头结点）进入到等待队列，如果该线程能够从await()方法返回的话一定是该线程获取了与condition相关联的lock
signal方法：调用condition的signal或者signalAll方法可以将等待队列中等待时间最长的节点移动到同步队列中，而移入到同步队列后才有机会使得等待线程被唤醒，即从await方法中的LockSupport.park(this)方法中返回，从而才有机会使得调用await方法的线程成功退出
等待/通知机制，通过使用condition提供的await和signal/signalAll方法就可以实现这种机制
线程awaitThread先通过lock.lock()方法获取锁成功后调用了condition.await方法进入等待队列，而另一个线程signalThread通过lock.lock()方法获取锁成功后调用了condition.signal或者signalAll方法，使得线程awaitThread能够有机会移入到同步队列中，当其他线程释放lock后使得线程awaitThread能够有机会获取lock，从而使得线程awaitThread能够从await方法中退出执行后续操作。如果awaitThread获取lock失败会直接进入到同步队列
与
wait，notify的区别？（最好使用notifyAll）
Object类的wait，notify方法，内部同样维护了同步队列和等待队列，不同的是它内部只维护了一个等待队列，当多个线程调用wait方法进入等待队列时，不能确定哪个线程位于等待队列的头节点，所以当调用notify唤醒的线程可能不是你想要唤醒的线程，这时必须调用notifyAll把所有线程都唤醒
公平锁与非公平锁的实现区别？
非公平锁的实现中，新加入同步队列（争锁失败）的节点，不会去判断队列中是否还有前驱节点，而直接首先尝试获取锁；公平锁里，新加入的节点会先去判断是否有前驱节点，若判断还有前驱节点，则会等待前驱节点都获取到锁并执行完退出，这样就保证了先入队列的线程优先拿到锁
//公平锁的实现
static final class FairSync extends Sync{
......
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//每次尝试获取锁时首先会判断是否有前驱节点，若有前驱节点就直接返回false
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
......
}