Java并发编程系列之Lock的使用

最新推荐文章于 2024-03-11 16:53:19 发布

谁喝了我的菊花茶

最新推荐文章于 2024-03-11 16:53:19 发布

阅读量114

点赞数

分类专栏： Java编程语言

Java编程语言专栏收录该内容

37 篇文章 0 订阅

订阅专栏

Jdk1.5中，在java.util.concurrent.locks包下，有一组实现线程同步的接口和类，说到线程的同步，很多立马就会想到synchronized关键字，这是java内置的关键字，用来处理线程同步的，但这个关键字有很多的缺陷，使用起来也不是很方便和直观，所以就出现了Lock，下面，我们就来对比着讲解Lock。

synchronized关键字：

该关键字在使用的过程中会有如下几个问题：

1、不可控性，无法做到随心的加锁和释放锁

2、效率比较低下，比如我们现在并发的读两个文件，读与读之间是互不影响的，但如果给这个读的对象使用synchronized来实现同步的话，那么只要有一个线程进入了，那么其他的线程都要等待。

3、无法知道线程是否获取到了锁

以上问题，Lock都可以很好的解决，并且jdk1.5还提供了各种锁，例如读写锁，但有一点需要注意，使用synchronized关键时，无须手动释放锁，但使用Lock必须手动释放锁。下面我们就来学习一下Lock锁。

Lock是一个上层的接口，其原型如下，总共提供了6个方法：

public interface Lock {
// 用来获取锁，如果锁已经被其他线程获取，则一直等待，直到获取到锁
void lock();
// 该方法获取锁时，可以响应中断，比如现在有两个线程，一个已经获取到了锁，另一个线程调用这个方法正在等待锁，但是此刻又不想让这个线程一直在这死等，可以通过调用线程的Thread.interrupted()方法，来中断线程的等待过程
void lockInterruptibly() throws InterruptedException;
// tryLock方法会返回bool值，该方法会尝试着获取锁，如果获取到锁，就返回true，如果没有获取到锁，就返回false，但是该方法会立刻返回，而不会一直等待
boolean tryLock();
// 这个方法和上面的tryLock差不多是一样的，只是会尝试指定的时间，如果在指定的时间内拿到了锁，则会返回true，如果在指定的时间内没有拿到锁，则会返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
// 实现线程通信，相当于wait和notify，后面会单独讲解
Condition newCondition();
}
那么这几个方法该如何使用了？前面我们说到，使用Lock是需要手动释放锁的，但是如果程序中抛出了异常，那么就无法做到释放锁，有可能引起死锁，所以我们在使用Lock的时候，有一种固定的格式，如下：

// 下面这段代码摘自官方文档
Lock l = ...;
l.lock();
try {
// access the resource protected by this lock
} finally {// 必须使用try，最后在finally里面释放锁
l.unlock();
}
下面我们来看一个简单的例子，代码如下：
/**
* 描述：Lock使用
*/
public class LockDemo {
   // new一个锁对象，注意此处必须声明成类对象，保持只有一把锁,ReentrantLock是Lock的唯一实现类
   Lock lock = new ReentrantLock();
   public void readFile(String fileMessage){
       lock.lock();// 上锁
       try{
           System.out.println(Thread.currentThread().getName()+"得到了锁，正在读取文件……");
           for(int i=0; i<fileMessage.length(); i++){
               System.out.print(fileMessage.charAt(i));
           }
           System.out.println();
           System.out.println("文件读取完毕！");
       }finally{
           System.out.println(Thread.currentThread().getName()+"释放了锁！");
           lock.unlock();
       }
   }

   public void demo(final String fileMessage){
       // 创建若干个线程
       ExecutorService service = Executors.newCachedThreadPool();
       // 提交20个任务
       for(int i=0; i<20; i++){
           service.execute(new Runnable() {
               @Override
               public void run() {
                   readFile(fileMessage);
                   try {
                       Thread.sleep(20);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           });
       }
// 释放线程池中的线程
       service.shutdown();
   }
}
我们先把锁的那两行代码注释掉，看下效果如何：

然后我们把锁的代码加上，看下效果如何：

如果我们把上面的readFile方法前面加上synchronized关键字，然后把锁去掉，效果是一样的。

tryLock锁的使用和Lock锁的使用类似，下面把示例代码贴出来，就不做过多的说明了，代码如下：

/**
* 描述：TryLock使用
*/
public class TryLockDemo {
   // new一个锁对象
   Lock lock = new ReentrantLock();
   public void readFile(String fileMessage){
       if(lock.tryLock()){
           try{
               System.out.println(Thread.currentThread().getName()+"得到了锁，正在读取文件……");
               System.out.println("文件读取完毕！");
           }finally{
               System.out.println(Thread.currentThread().getName()+"释放了锁！");
               lock.unlock();
           }
       }else{
           System.out.println(Thread.currentThread().getName()+"获取锁失败!");
       }
   }

   public void demo(final String fileMessage){
       // 创建若干个线程
       ExecutorService service = Executors.newCachedThreadPool();
       // 提交200个任务
       for(int i=0; i<200; i++){
           service.execute(new Runnable() {
               @Override
               public void run() {
                   readFile(fileMessage);
               }
           });
       }
       // 释放线程池中的线程
       service.shutdown();
   }
}
测试效果如下：