Java并发编程Lock显示锁的了解

Lock是一个接口提供无条件的,可轮询的 ,定时的,可中断的锁获取操作,所有加锁和解锁的方法都是显示的。

Lock接口方法

  public abstract void lock(); //获取锁

这个就是平常用的最多的方法,用来获取锁,如果没有获取到锁则等待。不过为了避免产生死锁,一般都要跟try{}finally{} 一起使用

  lock.lock(); //获取锁
        try {
            //业务处理
        }finally {
            lock.unlock(); //释放锁
        }
    }
 public abstract void unlock(); //释放锁

用来释放锁,这个没什么好细说,用的时候,注意一定在finally包裹里使用,不然容易出现死锁。

    public abstract void lockInterruptibly()throws InterruptedException; //获取锁

这个方法是也是获取锁,跟lock() 跟相似,获取锁,获取不到,等待直到获取到锁为止。但是它是可以被中断的,这个方法直接throws InterruptedException 就是为了让调用者,自己去处理线程的中断。这个方法强调的是线程在获取锁的时候可以被中断,获取到锁的时候也可以被中断,详细看下面的例子。

 void method()throws InterruptedException{
try {
            //业务处理
        }finally {
            lock.unlock(); //释放锁
        }
}
public abstract boolean tryLock(); //获取锁,有返回值

这个方法与lock()主要的区别在,lock()方法获取不到锁,会等待,直到获取到锁为止。tryLock()只会获取一次,并将结果返回,获取到锁返回true,反之false。代码模板:

if(lock.tryLock()) {
            try {
            //上锁的业务处理   
            }finally {
                lock.unlock(); //释放锁
            }
        }else {
            //获取锁失败的业务处理
        }
  public void tryLock(long paramLong,TimeUnit paramTimeUnit) throws InterruptedException;

这个方法与tryLock()有点类似,在指定的时间内获取锁,如果没有获取到返回false,如果在指定的时间内,获取到锁则返回true。使用模板也与tryLock() 一样。

  public abstract Condition newCondition();

返回用来与此Lock实例一起使用的Condition实例。

Lock实现ReentrantLock 使用

lock() 方法使用

public class LockDemo {
    
    private List list = new ArrayList<>();
    private final ReentrantLock lock = new ReentrantLock();
    
    public static void main(String[] args) throws InterruptedException {
        final LockDemo l = new LockDemo();
        for(int i = 0; i < 5 ; i++) {
          new Thread(()->{l.insert(Thread.currentThread());}).start(); 
        }
        Thread.sleep(2000); //为了看到list的结果,谁两秒钟
        System.out.println("执行完成了");
        l.list.forEach(System.out::println);
        
    }
    
   public   void insert(Thread thread) {
        lock.lock();
        try {
        System.out.println("此线程已经获取到锁了 "+thread.getName());
        list.add(thread.getName());
        }finally {
            lock.unlock();
            System.out.println("此线程已经释放锁了 "+thread.getName());
        }
    }
   }

}

执行结果

此线程已经获取到锁了 Thread-1
此线程已经释放锁了 Thread-1
此线程已经获取到锁了 Thread-0
此线程已经释放锁了 Thread-0
此线程已经获取到锁了 Thread-3
此线程已经释放锁了 Thread-3
此线程已经获取到锁了 Thread-4
此线程已经释放锁了 Thread-4
此线程已经获取到锁了 Thread-2
此线程已经释放锁了 Thread-2
执行完成了
Thread-1
Thread-0
Thread-3
Thread-4
Thread-2

可以看出获取锁的顺序跟list的顺序是一样。每个线程都是先获取到锁,释放锁在到下一个线程,不存在交叉的情况。

tryLock() 方法使用

public class LockDemo {
    private List list = new ArrayList<>();
    private final ReentrantLock lock = new ReentrantLock();
    
    public static void main(String[] args) throws InterruptedException {
        final LockDemo l = new LockDemo();
        for(int i = 0; i < 5 ; i++) {
          new Thread(()->{l.tryInsert(Thread.currentThread());}).start(); 
        }
        Thread.sleep(2000);
        System.out.println("执行完成了");
        l.list.forEach(System.out::println);    
    }
   void tryInsert(Thread thread) {
       if(lock.tryLock()) {//tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(
           System.out.println("此线程已经获取到锁了 "+thread.getName());                              //即锁已被其他线程获取),
           try {              //则返回false,也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 这个方法就是线程 去竞争锁,获取到执行 不然到else里面去
           list.add(thread.getName());
           }finally {
               lock.unlock();
               System.out.println("此线程已经释放锁了 "+thread.getName());
           }
       }else {
           System.out.println("此线程获取锁失败 "+thread.getName());
       }
   }
}

执行的结果

此线程获取锁失败 Thread-0
此线程获取锁失败 Thread-3
此线程获取锁失败 Thread-1
此线程获取锁失败 Thread-2
此线程已经获取到锁了 Thread-4
此线程已经释放锁了 Thread-4
执行完成了
Thread-4

可以看出5个线程同时获取锁,只有一个线程成功的,其他的线程都进入else中。这个对应开头说的可轮询的,如果加上时间就是定时的。

lockInterruptibly()方法使用

public class LockDemo {

    private List list = new ArrayList<>();
    private final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        final LockDemo l = new LockDemo();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(() -> {
                l.interruptInsert(Thread.currentThread());
            });
            t.start();
            if (i % 2 == 0) {//对偶数进行中断,为了不让全部的线程都中断,list没有结果集
                Thread.sleep(10); //让线程获取去获取锁,在进行中断
                t.interrupt(); // 直接执行中断 
            }
        }
        Thread.sleep(5000);
        System.out.println("执行完成了");
        l.list.forEach(System.out::println);

    }

    void interruptInsert(Thread thread) {
        try {
            lock.lockInterruptibly();
            System.out.println("线程已经获取到锁了 : " + thread.getName());
            Thread.sleep(2000);
            list.add(thread.getName());
        } catch (InterruptedException e) {
            System.out.println("当前线程直接执行中断: " + thread.getName());
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
            System.out.println("此线程已经释放锁了 " + thread.getName());
        }
    }
}

![image.png](https://upload-images.jianshu.io/upload_images/9213940-21a3f18890d75f77.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

可以看出Thread-0,Thread-2 已经获取到锁了,还是被中断,Thread-4在等待获取锁,直接被中断的,终止等待。


          

你可能感兴趣的