java 并发编程lock使用详解

原创

gmHappy 2021-07-29 09:20:39 博主文章分类：Java ©著作权

文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者gmHappy的原创作品，请联系作者获取转载授权，否则将追究法律责任

浅谈Synchronized:

synchronized是Java的一个关键字,也就是Java语言内置的特性,如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,执行代码块时,其他线程

便只能一直等待,等待获取锁的线程释放锁,而获取锁的线程释放锁会有三种情况:

1).获取锁的线程执行完该代码块,然后线程释放对锁的占有;

2).线程执行发生异常,此时JVM会让线程自动释放锁;

3).调用wait方法,在等待的时候立即释放锁,方便其他的线程使用锁.

Lock的特性:

1).Lock不是Java语言内置的,synchronized是Java语言的关键字,因此是内置特性.Lock是一个类,通过这个类可以实现同步访问;

2).synchronized是在JVM层面上实现的,如果代码执行出现异常,JVM会自动释放锁,但是Lock不行,要保证锁一定会被释放,就必须将unLock放到finally{}中(手动释放);

3).在资源竞争不是很激烈的情况下,synchronized的性能要优于ReetarntLock,但是在很激烈的情况下,synchronized的性能会下降几十倍;

Lock的使用方式:

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

下面来逐个讲述Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。newCondition()下个章节讲述.

在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢?

lock()方法是平常使用得最多的一个方法,就是用来获取锁.如果锁已被其他线程获取,则进行等待.

由于在前面讲到如果采用Lock,必须主动去释放锁,并且在发生异常时,不会自动释放锁.因此一般来说,使用Lock必须在try{}catch{}块中进行,并且将释放锁的操作放在finally块中进行,以保证锁一定被被释放,防止死锁的发生.通常使用Lock来进行同步的话，是以下面这种形式去使用的：
```
Lock lock = ...;
lock.lock();
try {
    //处理任务
} catch(Exception e) {
     
} finally {
    lock.unlock();  //释放锁
}
```
tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true;如果获取失败（即锁已被其他线程获取）,则返回false,也就说这个方法无论如何都会立即返回.在拿不到锁时不会一直在那等待.

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false.如果如果一开始拿到锁或者在等待期间内拿到了锁,则返回true.

所以,一般情况下通过tryLock来获取锁时是这样使用的：
```
Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}
```
lockInterruptibly()方法比较特殊,当通过这个方法去获取锁时,如果线程正在等待获取锁,则这个线程能够响应中断,即中断线程的等待状态.也就使说,当两个线程同时通过lock.lockInterruptibly()想获取某个锁时,假若此时线程A获取到了锁,而线程B只有在等待,那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程.

由于lockInterruptibly()的声明中抛出了异常,所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException.

因此lockInterruptibly()一般的使用形式如下:
```
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestLock {

	public static void main(String[] args) {
		Thread t1 = new Thread(new RunTt());
		Thread t2 = new Thread(new RunTt());

		t1.start();
		t2.start();
		t2.interrupt();
	}
}

class RunTt implements Runnable {

	private static Lock lock = new ReentrantLock();

	public void run() {
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + " running");
			TimeUnit.SECONDS.sleep(5);
			System.out.println(Thread.currentThread().getName() + " finished");
		} catch (InterruptedException e) {
			System.out.println(Thread.currentThread().getName() + " interrupted");
		} finally {
			lock.unlock();
		}
	}
}
```
运行结果:

将代码:lock.lock(); 修改成:lock.lockInterruptibly();

运行结果：
　
总结：
- 使用lockInterruptibly时当前线程可以被其他线程中止,并且在其他线程中抛出异常信息;
- 使用lock时,当前线程也可以被其他线程中止,但不会抛出异常信息;

Condition的特性:

1.Condition中的await()方法相当于Object的wait()方法,Condition中的signal()方法相当于Object的notify()方法,Condition中的signalAll()相当于Object的notifyAll()方法.不同的是,Object中的这些方法是和同步锁捆绑使用的;而Condition是需要与互斥锁/共享锁捆绑使用的.

2.Condition它更强大的地方在于:能够更加精细的控制多线程的休眠与唤醒.对于同一个锁,我们可以创建多个Condition,在不同的情况下使用不同的Condition.

public interface Condition {
     //使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁。与Object.wait()类似。
    void await() throws InterruptedException;

    //调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
    //调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。 
    void awaitUninterruptibly();

    // 调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
    //nanosTimeout指定该方法等待信号的的最大时间（单位为纳秒）。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；
    //若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。 
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    //与await()基本一致，唯一不同点在于，指定时间之内没有收到signal()或signalALL()信号或者线程中断时该方法会返回false;其它情况返回true。
    boolean await(long time, TimeUnit unit) throws InterruptedException;

   //适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻。
    boolean awaitUntil(Date deadline) throws InterruptedException;
    
    //唤醒一个在 await()等待队列中的线程。与Object.notify()相似
    void signal();

   //唤醒 await()等待队列中所有的线程。与object.notifyAll()相似
    void signalAll();
}

object.wait和condition.await的区别

使用上，wait必须用在synchronized中，await必须用在lock.lock()中叫醒方式不同，wait对应notify，await对应signal，condition能实现更细粒度的线程调度。

为甚需要多个condition？一个condition是否可以

Condition的强大之处在于它可以为多个线程间建立不同的Condition（相当于建立了多把锁），使用synchronized/wait()只有一个阻塞队列，notifyAll会唤起所有阻塞队列下的线程，而使用lock/condition，可以实现多个阻塞队列，signalAll只会唤起某个阻塞队列下的阻塞线程。