并发编程之Lock锁（上）

Lock

它是一个接口，提供了以下的方法
tryLock是返回一个布尔值，如果未抢占到锁不会阻塞，直接跳过
lock是抢占锁，如果未抢到那么就阻塞，等待唤醒
lockInterruptibly是可中断锁

具体实现有以下

用的最多的就是ReentrantLock了

ReentrantLock

案例

public class LockDemo {
    static Lock lock=new ReentrantLock();
    private static int count=0;
    public static void inc(){
        lock.lock();
        try {
            Thread.sleep(1);
            count++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();//释放锁一定要在finally里面去做
        }
    }
    public static void main(String[] args) {
        for (int i=0;i<1000;i++){
            new Thread(()->LockDemo.inc()).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

可以看到和Synchronized能起到一样的效果，两者性能差异不大参考文章，Synchronized更方便一些！

ReentrantLock的设计思想

靠自己先猜有以下这些点

• 一定会设计到锁的抢占 ， 需要有一个标记来实现互斥。 全局变量（0，1）
• 抢占到了锁，怎么处理（不需要处理.）
• 没抢占到锁，怎么处理？
  • 需要等待（让处于排队中的线程，如果没有抢占到锁，则直接先阻塞，阻塞可以释放CPU资源）。
    • 如何让线程等待？
      • wait/notify(线程通信的机制，无法指定唤醒某个线程)
      • LockSupport.park/unpark（阻塞一个指定的线程，唤醒一个指定的线程）
      • Condition
  • 需要排队（此时线程处于活跃状态）。
    • 通过一个数据结构，把这N个排队的线程存储起来。
• 抢占到锁的释放过程，如何处理
  • LockSupport.unpark() ，即唤醒处于队列中的指定线程.
• 锁抢占的公平性（是否允许插队）
  • 公平
  • 非公平

以上流程都是在AbstractQueuedSynchronizer即AQS中实现的。

AQS提供了两种锁的机制

• 互斥锁（同时只能一个线程获得）
• 共享锁（同时可以由多个线程获得）

总结流程图