这篇文章将为大家详细讲解有关怎么深入理解Java中的锁,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。
代码示例:
public class GetLockDemo { // 公平锁 // static Lock lock =new ReentrantLock(true); // 非公平锁 static Lock lock = new ReentrantLock(); public static void main(String[] args) throws InterruptedException { // 主线程 拿到锁 lock.lock(); Thread thread = new Thread( () -> { // 子线程 获取锁(不死不休) System.out.println("begain to get lock..."); lock.lock(); System.out.println("succeed to get lock..."); // // 子线程 获取锁(浅尝辄止) // boolean result = lock.tryLock(); // System.out.println("是否获得到锁:" + result); // // // 子线程 获取锁(过时不候) // try { // boolean result1 = lock.tryLock(5, TimeUnit.SECONDS); // System.out.println("是否获得到锁:" + result1); // } catch (InterruptedException e) { // e.printStackTrace(); // } // // // 子线程 获取锁(任人摆布) // try { // System.out.println("start to get lock Interruptibly"); // lock.lockInterruptibly(); // } catch (InterruptedException e) { // e.printStackTrace(); // System.out.println("dad asked me to stop..."); // } }); thread.start(); Thread.sleep(10000L); lock.unlock(); }}
结论:
lock() 最常用
lockInterruptibly() 方法一般更昂贵,有的实现类可能没有实现 lockInterruptible() 方法。
只有真的需要用中断时,才使用,使用前应看清实现类对该方法的描述。
condition代码示例:
public class ConditionDemo { static Lock lock = new ReentrantLock(); static Condition condition = lock.newCondition(); public static void main(String[] args) throws InterruptedException { Thread thread = new Thread( () -> { lock.lock(); System.out.println("condition.await()"); try { condition.await(); System.out.println("here i am..."); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } }); thread.start(); Thread.sleep(2000L); lock.lock(); condition.signalAll(); lock.unlock(); }}
ReentrantLock是可重入锁,同一线程可以多次获取到锁
ReentrantLock需要一个owner用来标记那个线程获取到了锁,一个count用来记录加锁的次数和一个waiters等待队列用来存放没有抢到锁的线程列表
当有线程进来时,会先判断count的值,如果count为0说明锁没有被占用
然后通过CAS操作进行抢锁
如果抢到锁则count的值会加1,同时将owner设置为当前线程的引用
如果count不为0同时owner指向当前线程的引用,则将count的值加1
如果count不为0同时owner指向的不是当前线程的引用,则将线程放入等待队列waiters中
如果CAS抢锁失败,则将线程放入等待队列waiters中
当线程使用完锁后,会释放其持有的锁,释放锁时会将count的值减1,如果count值为0则将owner设为null
如果count值不为0则会唤醒等待队列头部的线程进行抢锁
手动实现ReentrantLock代码示例:
public class MyReentrantLock implements Lock { // 标记重入次数的count值 private AtomicInteger count = new AtomicInteger(0); // 锁的拥有者 private AtomicReference<Thread> owner = new AtomicReference<>(); // 等待队列 private LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>(); @Override public boolean tryLock() { // 判断count是否为0,若count!=0,说明锁被占用 int ct = count.get(); if (ct != 0) { // 判断锁是否被当前线程占用,若被当前线程占用,做重入操作,count+=1 if (owner.get() == Thread.currentThread()) { count.set(ct + 1); return true; } else { // 若不是当前线程占用,互斥,抢锁失败,return false return false; } } else { // 若count=0, 说明锁未被占用,通过CAS(0,1) 来抢锁 if (count.compareAndSet(ct, ct + 1)) { // 若抢锁成功,设置owner为当前线程的引用 owner.set(Thread.currentThread()); return true; } else { return false; } } } @Override public void lock() { // 尝试抢锁 if (!tryLock()) { // 如果失败,进入等待队列 waiters.offer(Thread.currentThread()); // 自旋 for (; ; ) { // 判断是否是队列头部,如果是 Thread head = waiters.peek(); if (head == Thread.currentThread()) { // 再次尝试抢锁 if (!tryLock()) { // 若抢锁失败,挂起线程,继续等待 LockSupport.park(); } else { // 若成功,就出队列 waiters.poll(); return; } } else { // 如果不是队列头部,就挂起线程 LockSupport.park(); } } } } public boolean tryUnlock() { // 判断,是否是当前线程占有锁,若不是,抛异常 if (owner.get() != Thread.currentThread()) { throw new IllegalMonitorStateException(); } else { // 如果是,就将count-1 若count变为0 ,则解锁成功 int ct = count.get(); int nextc = ct - 1; count.set(nextc); // 判断count值是否为0 if (nextc == 0) { owner.compareAndSet(Thread.currentThread(), null); return true; } else { return false; } } } @Override public void unlock() { // 尝试释放锁 if (tryUnlock()) { // 获取队列头部, 如果不为null则将其唤醒 Thread thread = waiters.peek(); if (thread != null) { LockSupport.unpark(thread); } } } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return false; } @Override public void lockInterruptibly() throws InterruptedException {} @Override public Condition newCondition() { return null; }}
synchronized:
优点:
使用简单,语义清晰,哪里需要点哪里
由JVM提供,提供了多种优化方案(锁粗化,锁消除,偏向锁,轻量级锁)
锁的释放由虚拟机完成,不用人工干预,降低了死锁的可能性
缺点:
悲观的排他锁,无法实现锁的高级功能如公平锁,读写锁等
Lock:
优点:可以实现synchronized无法实现的锁的高级功能如公平锁,读写锁等,同时还可以实现更多的功能
缺点:需手动释放锁unlock,使用不当容易造成死锁
结论: 两者都是可重入锁,synchronized可以类比为傻瓜相机,提供了固定的功能,而Lock可以类比为单方,可以根据需要调节所需的功能
关于怎么深入理解Java中的锁就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果觉得文章不错,可以把它分享出去让更多的人看到。
亿速云「云服务器」,即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘,价格低至29元/月。点击查看>>
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。
原文链接:https://my.oschina.net/codingdiary/blog/4358552