Lock和Synchronized的比较

之前看到在并发中的currentHashMap和HashTable，两者都是线性安全的，但其实现却不同；

currentHashMap底层通过java.util.concurrent.locks包的lock实现同步，针对共享数据进行加锁；

HashTable通过synchronized关键字对代码块进行实现同步；这里对lock和synchronized进行详细的比较。

比较之前，说一下他们的共同目的：在并发的情况下，实现同步，保证线程安全。

那么，其中线程安全是指，在多线程的情形下，对公共资源的顺序访问不会相互影响执行结果。

还有，并行和并发区别是：

并行是多台cpu 同时进行计算运行；

而并发是通过合理的cpu算法调度，充分利用cpu资源的一种多线程手段；

好了，理清一下基本相关的问题，下面介绍实现同步确保线程安全的两种方法的不同。

思考一下，线程中最早实现同步是用的synchroinized，为什么又出现了lock?

原因是，synchroinized有不尽人意的地方。

当synchroinized在代码块中获取到对象的锁之后，其他线程将进入等待状态，如果有锁对象一直等呆某个IO，那么其他线程将一直等待下去，在线程数量较多情况下，性能不容乐观。

（Synchronized属于非中断锁）

（单独调用interrupt()方法只能中断处于阻塞状态的先，运行中的线程无法中断）

而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()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

　由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

lock.lock();
try{
//处理任务
}catch(Exception ex){

}finally{
lock.unlock();   //释放锁
}

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

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

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。

public void method() throws InterruptedException {
lock.lockInterruptibly();
try {
//.....
}
finally {
lock.unlock();
}
}

当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

　而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

总的来说：（Lock提供了比synchronized更多的功能）

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

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