显示锁和AQS及其原理

最新推荐文章于 2023-03-28 15:36:55 发布

lw_yang

最新推荐文章于 2023-03-28 15:36:55 发布

阅读量1.3k

点赞数 1

分类专栏：并发编程文章标签： lock java AQS sync

本文链接：https://blog.csdn.net/Sophisticated_/article/details/93877331

版权

并发编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

显示锁

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;
                }
            }
            ......
}

lw_yang

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
显示锁和AQS及其原理

显示锁Lock和Synchronized：优先使用Synchronized关键字，除非需要获取锁可以被中断，超时获取锁，尝试获取锁的功能公平锁和非公平锁：如果在时间上，先对锁获取的请求，一定先被满足，这个锁是公平的，不满足就是非公平的，非公平锁一般效率更高读写锁（ReadWriteLock）：Lock和Synchronized都是排它锁，而读写锁同一时刻允许多个线程同时访问，但是写线程访问的...
复制链接

扫一扫