中秋节，漫漫长夜，岂能虚度。。。不睡了，爬起来写点啥吧
线程安全控制策略中，之前介绍了synchronized关键字，它出现在Java5.0之前。在Java5.0中，增加了新的Lock接口也可以实现锁的功能。Lock的功能和synchronized的功能相似，只是synchronized是Java的内置特性，在JVM层面实现了对临界资源的同步访问，隐式地获取锁和释放锁，而Lock在使用时需要显式地获取和释放锁，比synchronized灵活，比如响应中断、得知线程是否成功获取锁等，但是需要记得使用完lock要释放，不释放可能会死锁。
Lock在java.util.concurrent.locks包下，除Lock外，还有队列同步器、重入锁、读写锁等，下面就简单介绍一下。
1、Lock接口
public interface Lock {
//获取锁
void lock();
//可中断地获取锁，与lock()的区别就是该方法在锁获取中可中断当前线程
void lockInterruptibly() throws InterruptedException;
//尝试非阻塞获取锁，调用方法后立刻返回，获取返回true,否则返回false
boolean tryLock();
//超时获取锁，三种情况下返回:①当前线程在超时时间内获得锁②当前线程在超时时间内被中断③超时时间结束，返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//释放锁
void unlock();
//获取等待通知组件，该组件和当前的锁绑定
Condition newCondition();
}
上面提到使用Lock，需手动释放锁，但在发生异常时，不会自动释放锁。所以，使用lock要在try{}中进行，释放锁要在finally中进行，保证锁一定被释放。
Lock lock = ……;
lock.lock();
try{
//处理任务
}catch(Exception e){
}finally{
//释放锁
lock.unlock();
}
tryLock()是有返回值的，尝试获取锁，成功返回true,失败返回false,会立即返回，而不是在拿不到锁时傻等着。
Lock lock = ……;
if(lock.tryLock()){
//获取锁
try{
//处理任务
}catch(Exception e){
}finally{
//释放锁
lock.unlock();
}
}else{
//没获取锁
}
lockInterruptibly(),使用此方法获取锁，可中断当前线程。如果线程正在等待获取锁，则这个线程能够相应中断。比如，两个线程A，B同时调用lock.lockInterruptibly()获取锁，如果A成功获取到锁，B只有等待，对线程B调用interrupt()就能中断B的等待过程。如果线程已经获取了锁，不会被interrupt()中断。因为interrupt()不能中断运行中的线程，只能中断阻塞线程。但是用synchronized，当一个线程处于等待状态，无法中断，只能一直等着。
2、ReentrantLock
public class ReentrantLock implements Lock, java.io.Serializable {
//省略
}
重入锁，实现了Lock接口，意思就是该锁支持一个线程对资源的重复加锁，当一个线程获取锁后能够再次获取锁而不会被锁阻塞。重入锁分为公平和非公平。
以上都是Lock接口的几个方法的介绍，下面通过案例测试下:
① lock()
public class Test9 {
Lock lock = new ReentrantLock();
public void insert(Thread thread){
lock.lock();
try {
System.out.println(thread.getName()+"获取了锁");
}catch (Exception e){
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
}
}
public static void main(String[] args) {
final Test9 test9 = new Test9();
new Thread(){
public void run(){
test9.insert(Thread.currentThread());
}
}.start();
new Thread(){
public void run(){
test9.insert(Thread.currentThread());
}
}.start();
}
}
运行结果：
获取一次锁，释放一次锁
将上例Test9中的insert(Thread thread)修改如下:
public void insert(Thread thread){
lock.lock();
lock.lock();
try {
System.out.println(thread.getName()+"获取了锁");
}catch (Exception e){
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
}
}
运行结果：
获取两次锁，释放一次锁
可以看到另一个线程一直处于阻塞状态，这是因为Lock接口实现的是可重入锁，线程进行了两次获取锁，却只执行了一次释放锁，所以所并没有彻底释放。
重入锁的最终释放
线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。
所以，两次获取锁需要两次释放锁，insert方法修改如下即可：
public void insert(Thread thread){
lock.lock();
lock.lock();
try {
System.out.println(thread.getName()+"获取了锁");
}catch (Exception e){
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
lock.unlock();
}
}
两次获取锁，两次释放锁
② tryLock()
public class Test9 {
Lock lock = new ReentrantLock();
public void insert(Thread thread){
if(lock.tryLock()){
try {
System.out.println(thread.getName()+"获取了锁");
}catch (Exception e){
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
}
}else{
System.out.println(thread.getName()+"获取锁失败");
}
}
public static void main(String[] args) {
final Test9 test9 = new Test9();
new Thread(){
public void run(){
test9.insert(Thread.currentThread());
}
}.start();
new Thread(){
public void run(){
test9.insert(Thread.currentThread());
}
}.start();
}
}
可以看出，Thread-0使用tryLock()成功获取锁后，Thread-1使用tryLock()尝试非阻塞地获取锁，获取失败，立即返回，返回了false。
③ lockInterruptibly()
public class MyThead implements Runnable{
private static Lock lock = new ReentrantLock();
@Override
public void run() {
try {
ddd();
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+" 线程中断");
}
}
private void ddd() throws InterruptedException{
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName()+" 获得了锁");
try{
System.out.println(Thread.currentThread().getName() + " running");
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName() + " finished");
}catch(InterruptedException e){
System.out.println(Thread.currentThread().getName() + " interrupted");
}finally{
lock.unlock();
}
}
}
public class Test10 {
public static void main(String[] args) throws Exception {
Thread t1 = new Thread(new MyThead());
Thread t2 = new Thread(new MyThead());
t1.start();
t2.start();
t2.interrupt();
}
}
运行结果：
可以看出，lockInterruptibly()允许在等待时由其他线程的Thread.interrupt()方法来中断等待线程而直接返回，这时是不用获取锁的，而会抛出一个InterruptException。
将MyThead——>ddd()方法中的"lock.lockInterruptibly();"修改为"lock.lock();"，再次运行，运行结果：
可以看出，lock()方法则不允许Thread.interrupt()中断，即使检测到了Thread.interruptted一样会继续尝试获取锁，失败则继续休眠。
3、ReadWriteLock
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing
*/
Lock writeLock();
}
ReadWriteLock是个接口，定义了两个方法，readLock来获取读锁，writeLock来获取写锁。将文件的读写操作分开，两个锁分别分配给线程，能使多个线程同时进行读操作。
4、ReentrantReadWriteLock
ReentrantReadWriteLock实现了ReadWriteLock接口。
分别启动两个线程，第一种方式是通过synchronized来实现，第二种方式通过读写锁完成。
public class Test10 {
public static void main(String[] args) throws Exception {
final Test10 test = new Test10();
new Thread(){
public void run(){
test.get(Thread.currentThread());
}
}.start();
new Thread(){
public void run(){
test.get(Thread.currentThread());
}
}.start();
}
public void get(Thread thread){
for(int i = 0 ; i < 50; i++){
System.out.println(thread.getName()+"正在进行读操作");
}
System.out.println(thread.getName()+"读操作完毕");
}
}
直到Thread-0执行完读操作之后，才会打印Thread-1执行读操作的信息。
public class Test10 {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) throws Exception {
final Test10 test = new Test10();
new Thread(){
public void run(){
test.get(Thread.currentThread());
}
}.start();
new Thread(){
public void run(){
test.get(Thread.currentThread());
}
}.start();
}
public void get(Thread thread){
rwl.readLock().lock();
try {
for(int i = 0 ; i < 50; i++){
System.out.println(thread.getName()+"正在进行读操作");
}
System.out.println(thread.getName()+"读操作完毕");
}finally {
rwl.readLock().unlock();
}
}
}
Thread-0和Thread-1交替执行，提高了读操作的效率。
不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
总结
本篇主要介绍了Lock接口、ReadWriteLock接口、ReentrantLock、ReentrantReadWriteLock的基础用法。
Lock和synchronized的区别：①Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；②synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；③Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；④通过Lock可以知道有没有成功获取锁，而synchronized却无法办到；⑤Lock可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。
本篇参考了《并发编程的艺术》，需要深入了解的同学可以阅读书籍《并发编程的艺术》、《并发编程实战》。
略陈固陋，如有不当之处，欢迎各位看官批评指正！
网友评论