首先要说明的就是Lock,通过查看Lock的源码可知,Lock是一个接口:
1
2
3
4
5
6
7
8
|
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来进行同步的话,是以下面这种形式去使用的:
1
2
3
4
5
6
7
8
9
|
Lock lock = ...;
lock.lock();
try
{
//处理任务
}
catch
(Exception ex){
}
finally
{
lock.unlock();
//释放锁
}
|
tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false,也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁,则返回true。
所以,一般情况下通过tryLock来获取锁时是这样使用的:
1
2
3
4
5
6
7
8
9
10
11
12
|
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()一般的使用形式如下:
1
2
3
4
5
6
7
8
9
|
public
void
method()
throws
InterruptedException {
lock.lockInterruptibly();
try
{
//.....
}
finally
{
lock.unlock();
}
}
|
注意,当一个线程获取了锁之后,是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程,只能中断阻塞过程中的线程。
因此当通过lockInterruptibly()方法获取某个锁时,如果不能获取到,只有进行等待的情况下,是可以响应中断的。
而用synchronized修饰的话,当一个线程处于等待某个锁的状态,是无法被中断的,只有一直等待下去。
以上摘自 海子的博客:http://www.cnblogs.com/dolphin0520/p/3923167.html
下面说说我的理解:
就是线程的interrupt方法会怎么终止一个线程:
分几种情况:
1、线程运行时,线程运行时,interrupt方法只会设置线程的中断标志,但是不会抛出异常,等到线程阻塞时再处理
2、线程阻塞时,会直接抛出异常
3、当线程处于锁等待时,如Lock的lock方法synchronized锁,这时的情况同1一样,不会立即处理异常,而是继续等待获取锁。
但是如果是Lock的lockInterruptibly方法时,在等待锁时,则会优先处理异常。
package qunaer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main1 {
static Lock lock=new ReentrantLock();
public static void main(String[] args) {
Thread t1= new Thread(){
public void run() {
try {
lock.lock();
System.out.println("1获取锁");
sleep(1000);
lock.unlock();
System.out.println("1释放锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("interrupted");
}
};
};
t1.start();
Thread t2= new Thread(){
public void run() {
try {
System.out.println(Thread.currentThread().isInterrupted());
sleep(10);
System.out.println(Thread.currentThread().isInterrupted());
lock.lock();
System.out.println("2获取锁");
System.out.println(Thread.currentThread().isInterrupted());
sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
// e.printStackTrace();
System.out.println("interrupted");
}
};
};
t2.start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t2.interrupt();
}
}
运行结果:
false
1获取锁
false
1释放锁
2获取锁
true
interrupted