Lock接口,比Synchronized更强大的锁

什么是并发问题？

当多个进程或线程同时访问同一资源时会产生并发问题。

例如：

当多个卖票窗口同时出售同一航空公司的机票.

当窗口A,窗口B,窗口C同时出售机票时，可能就会导致同一张机票会被多次卖出。

—- 示例代码：

//出售机票类
public class SellTicket implements Runnable {
    //剩余机票数量
    private int  ticketNum = 100;
    @Override
    public void run() {
        //出售机票
        while(true){
            try {
                //让线程休眠100毫秒
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //当剩余大于0时，才能出售机票
            if(ticketNum>0){
                System.out.println(Thread.currentThread().getName()+
			 "正在售出剩余的第"+(ticketNum--)+"张票。");
	   }else{
	       break;
	   }
	}
    }
}

—- 测试代码：

public class Test {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st,"窗口A");
        Thread t2 = new Thread(st,"窗口B");
        Thread t3 = new Thread(st,"窗口C");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

—- 显示结果

这就是典型的并发问题。如何解决？可以用锁

锁 是线程控制的重要途径。

Java为此也提供了2种锁机制，synchronized 和 Lock.

关键字 synchronized

synchronized是java中的一个关键字，也就是Java语言内置的特性。

synchronized(隐式锁)，在需要同步的对象中加入此控制，synchronized 可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。

1. synchronized 在方法上

public class Test {
    public synchronized void method(int num){
        //需要同步的代码
        .......
    }
}

2. synchronized 在特定的代码块

public class Test {
    public  void method(int num){
        //括号中表示需要锁的对象
        synchronized (this) {
            //需要同步的代码
            ......
        }
    }
}

使用synchronized解决并发问题

修改代码如下：

public class SellTicket implements Runnable {
    //剩余机票数量
    private int  ticketNum =100;
    
    @Override
    public  void run() {
        //出售机票
        while(true){
            try {
            //让线程休眠100毫秒
            Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //加上同步锁
            synchronized (this) {
                if(ticketNum>0){
                    System.out.println(Thread.currentThread().getName()+
                    "正在售出剩余的第"+(ticketNum--)+"张票。");
                }else{
                    break;
                }
            }
        }
    }
}

既然可以通过synchronized来实现同步访问，那么java为什么还需要提供Lock？

synchronized的缺陷

我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

1. 获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2. 线程执行发生异常，此时JVM(java虚拟机)会让线程自动释放锁。

如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程也就只能一直无期限地等待下去，这多么影响程序的执行效率.

因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

从java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。

Lock提供了比synchronized更多的功能。但是要注意以下几点:

1. Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个接口，通过它的实现类可以实现同步访问；

2. Lock和synchronized有一点非常大的不同，采用synchronized不需要用户手动的释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户手动释放锁，如果没有主动释放锁，就有可能导致出现 死锁 现象。

Lock

Lock（显示锁）：需要显示指定起始位置和终止位置。

一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过 lock( ) 和 unlock( ) 显示指出。所以一般会在finally块中写unlock( )以防死锁。

– 先看Api

Lock 是一个接口.

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作,此实现允许更灵活的结构.

它提供了 6 个 方法 如下：

其中获取锁的方法有 4 个：

lock( )方法

是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{ }catch{ }块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

tryLock( ) 方法

方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

tryLock(long time, TimeUnit unit)方法

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

lockInterruptibly( ) 方法

此方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程

以上是获取锁的4个方法。

---

newCondition( )

此方法暂且不在此讲述

unLock( )方法

方法是用来释放锁的

ReentrantLock 类

ReentrantLock 意思是“可重入锁”.

ReentrantLock是实现了Lock接口的类，并且ReentrantLock提供了更多的方法。

下面通过一些实例具体看一下如何使用ReentrantLock

使用 Lock 解决并发问题

修改后的出售机票类代码为：

 public class SellTicket implements Runnable {
    //剩余机票数量
    private int  ticketNum =100;
    //创建锁
    private Lock lock = new ReentrantLock(); // 注意这里的 创建了一把锁
    @Override
    public  void run() {
        //出售机票
        while(true){
            try {
                //让线程休眠100毫秒
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //使用Lock 解决并发
            //获得锁
            lock.lock(); //上锁
            try {
                if(ticketNum>0){
                    System.out.println(Thread.currentThread().getName()+
                    "正在售出剩余的第"+(ticketNum--)+"张票。");
                }else{
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                //使用lock时,一定记住在finally块中释放锁防止死锁的发生。
                lock.unlock(); //释放锁
            }
        }
    }
}

与锁相关的几个概念

1.可重入锁

如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。

举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

如果两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。

由于synchronized和Lock都具备可重入性，所以不会发生上述现象.

2. 可中断锁

可中断锁：顾名思义，就是可以相应中断的锁。
在Java中，synchronized就不是可中断锁，而Lock是可中断锁。

例如：

如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

3.公平锁

公平锁即尽量以请求锁的顺序来获取锁。

比如同时有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该锁，这种就是公平锁。

非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

而对于ReentrantLock，它默认情况下是非公平锁，但是可以设置为公平锁。

从ReentrantLock类的构造方法中可以看出

4. 读写锁

读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

关于面试题

1 .简述synchronized和java.util.concurrent.locks.Lock的异同 ？

Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。