大橙子网站建设,新征程启航

为企业提供网站建设、域名注册、服务器等服务

Java中的锁实现原理及优缺点

本篇内容介绍了“Java中的锁实现原理及优缺点”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

创新互联是一家专业提供鄞州企业网站建设,专注与成都网站制作、成都做网站、H5建站、小程序制作等业务。10年已为鄞州众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。

locks包结构层次

Lock 接口

方法签名描述
void lock();获取锁(不死不休)
boolean tryLock();获取锁(浅尝辄止)
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;获取锁(过时不候)
void lockInterruptibly() throws InterruptedException;获取锁(任人摆布)
void unlock();释放锁
Condition newCondition();

代码示例:

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

Object中的wait(), notify(), notifyAll()方法是和synchronized配合使用的可以唤醒一个或者多个线程。Condition是需要与Lock配合使用的,提供多个等待集合和更精确的控制(底层是park/unpark机制); | 协作方式 | 死锁方式1 (锁) | 死锁方式2(先唤醒,再挂起)| 备注 | | ---- | ---- | ---- |---- | | suspend/resume | 死锁 | 死锁 | 弃用 | | wait/notify | 不死锁 | 死锁 | 只用于synchronized关键字 | | park/unpark | 死锁 | 不死锁 | | | condition | 不死锁 | 死锁 | |

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();
  }
}

ReetrantLock

ReentrantLock是可重入锁,同一线程可以多次获取到锁 Java中的锁实现原理及优缺点

ReentrantLock实现原理分析

  1. ReentrantLock需要一个owner用来标记那个线程获取到了锁,一个count用来记录加锁的次数和一个waiters等待队列用来存放没有抢到锁的线程列表

  2. 当有线程进来时,会先判断count的值,如果count为0说明锁没有被占用

  3. 然后通过CAS操作进行抢锁

  4. 如果抢到锁则count的值会加1,同时将owner设置为当前线程的引用

  5. 如果count不为0同时owner指向当前线程的引用,则将count的值加1

  6. 如果count不为0同时owner指向的不是当前线程的引用,则将线程放入等待队列waiters中

  7. 如果CAS抢锁失败,则将线程放入等待队列waiters中

  8. 当线程使用完锁后,会释放其持有的锁,释放锁时会将count的值减1,如果count值为0则将owner设为null

  9. 如果count值不为0则会唤醒等待队列头部的线程进行抢锁

手动实现ReentrantLock代码示例:

public class MyReentrantLock implements Lock {

  // 标记重入次数的count值
  private AtomicInteger count = new AtomicInteger(0);

  // 锁的拥有者
  private AtomicReference owner = new AtomicReference<>();

  // 等待队列
  private LinkedBlockingDeque 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 VS Lock

synchronized: 优点:

  • 使用简单,语义清晰,哪里需要点哪里

  • 由JVM提供,提供了多种优化方案(锁粗化,锁消除,偏向锁,轻量级锁)

  • 锁的释放由虚拟机完成,不用人工干预,降低了死锁的可能性

缺点:悲观的排他锁,无法实现锁的高级功能如公平锁,读写锁等

Lock: 优点:可以实现synchronized无法实现的锁的高级功能如公平锁,读写锁等,同时还可以实现更多的功能 

缺点:需手动释放锁unlock,使用不当容易造成死锁

结论: 两者都是可重入锁,synchronized可以类比为傻瓜相机,提供了固定的功能,而Lock可以类比为单方,可以根据需要调节所需的功能

“Java中的锁实现原理及优缺点”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站,小编将为大家输出更多高质量的实用文章!


当前文章:Java中的锁实现原理及优缺点
标题URL:http://dzwzjz.com/article/jpgddg.html
在线咨询
服务热线
服务热线:028-86922220
TOP