0
点赞
收藏
分享

微信扫一扫

java 并发编程lock使用详解

言诗把酒 2022-02-13 阅读 109


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

运行结果:
java 并发编程lock使用详解_阻塞队列
将代码:​​lock.lock();​​ 修改成:​​lock.lockInterruptibly();​

运行结果:
java 并发编程lock使用详解_java_02 
总结:


  • 使用​​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只会唤起某个阻塞队列下的阻塞线程。


为啥强制wait必须用在synchronized中?否则IllegalMonitorStateException


调用wait()就是释放锁,释放锁的前提是必须要先获得锁,先获得锁才能释放锁。

notify(),notifyAll()是将锁交给含有wait()方法的线程,让其继续执行下去,如果自身没有锁,怎么叫把锁交给其他线程呢;



举报

相关推荐

0 条评论