《Java中Lock和synchronized的比较和应用》

《Java中Lock和synchronized的比较和应用》

尽管synchronized在语法上已经足够简单了，在JDK 5之前只能借助此实现，但是由于是独占锁，性能却不高，因此JDK 5以后就开始借助于JNI来完成更高级的锁实现。

JDK 5中的锁是接口java.util.concurrent.locks.Lock。另外java.util.concurrent.locks.ReadWriteLock提供了一对可供读写并发的锁。我们从java.util.concurrent.locks.Lock的使用，可以查询API文档，这里不再说明。

java.util.concurrent.locks.Lock类，既然是锁，肯定有用于线程获取锁和释放锁的方法存在，这两个方法为：

1、void lock();

函数功能：获取锁。如果锁不可用，由于线程调度目的，将禁用此线程，并且在获得锁之前，该线程将一直处于休眠状态。

2、unlock();

函数功能：释放锁。对应于所有的获取锁，例如lock()、tryLock()、tryLock(xx)、lockInterruptibly()等操作，如果成功的话应该对应着一个unlock()，这样可以避免死锁或者资源浪费。

使用Lock同步来模拟AtomicInteger类

我们知道AtomicInteger类是一个int型原子操作类。下面我们就使用Lock类来模拟实现一个AtomicInteger。

在模拟实现之前，我们如果不太了解AtomicInteger，可以先看下这个类的API文档以及AtomicInteger源码实现。

AtomicInteger的所有原子操作都依赖于sun.misc.Unsafe类，Unsafe类中相关操作都是对应于一条与平台有关的处理器CAS指令。

使用锁Lock模拟的AtomicInteger类代码如下：

类代码虽长，但思路相当简单。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AtomicIntegerLock {

private volatile int value;

private Lock lock = new ReentrantLock();

public AtomicIntegerLock(int value) {
this.value = value;
}

public void set(int newValue){
lock.lock();
try{
this.value = newValue;
}finally{
lock.unlock();
}
}

public final int get(){
lock.lock();
try{
return value;
}finally{
lock.unlock();
}
}

public final int getAndSet(int newValue){
lock.lock();
try{
int oldValue = value;
value = newValue;
return oldValue;
}finally{
lock.unlock();
}
}

public final int getAndAdd(int delta){
lock.lock();
try{
int oldValue = value;
value+=delta;
return oldValue;
}finally{
lock.unlock();
}
}

public final int addAndGet(int delta){
lock.lock();
try{
value+=delta;
return value;
}finally{
lock.unlock();
}
}

public final boolean getAndCompare(int expect,int newValue){
lock.lock();
try{
if(this.value == expect){
value = newValue;
return true;
}
else{
return false;
}
}finally{
lock.unlock();
}
}

public final int getAndIncrement(){
lock.lock();
try{
return value++;
}finally{
lock.unlock();
}
}

public final int getAndDecrement(){
lock.lock();
try{
return value--;
}finally{
lock.unlock();
}
}

public final int incrementAndGet(){
lock.lock();
try{
return ++value;
}finally{
lock.unlock();
}
}

public final int decrementAndGet(){
lock.lock();
try{
return --value;
}finally{
lock.unlock();
}
}

public final String  toString(){
return Integer.toString(get());
}

}

Lock同步和synchronized同步两种锁的性能

下面我们使用synchronized和Lock分别进行同步的性能比较：分别开启10个线程，每个线程计数到1000000，统计两种锁同步所花费的时间

public class TestAtomicIntegerLock {

private static int synValue = 0;
public static void main(String[] args) {
int threadNum = 10;
int maxValue = 1000000;

Thread[] t = new Thread[threadNum];
Long begin = System.nanoTime();
for(int i=0;i<threadNum;i++){
AtomicIntegerLock aIL = new AtomicIntegerLock(0);
t[i]=new Thread(new Runnable(){

@Override
public void run() {
for(int j=0;j<maxValue;j++){
aIL.getAndIncrement();
}
}

});
}
for(int i=0;i<threadNum;i++){
t[i].start();
}
//main线程等待前面开启的所有线程结束
for(int i=0;i<threadNum;i++){
try {
t[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println("使用lock所花费的时间为："+(System.nanoTime()-begin));

int[] lock = new int[0];
begin = System.nanoTime();
for(int i=0;i<threadNum;i++){
synValue = 0;
t[i]=new Thread(new Runnable(){

@Override
public void run() {
for(int j=0;j<maxValue;j++){
synchronized(lock){
++synValue;
}
}
}

});
}
for(int i=0;i<threadNum;i++){
t[i].start();
}
//main线程等待前面开启的所有线程结束
for(int i=0;i<threadNum;i++){
try {
t[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println("使用synchronized所花费的时间为："+(System.nanoTime()-begin));

}

}

结果如下：

使用lock所花费的时间为：489742547
使用synchronized所花费的时间为：1660636784

从时间数字来看，可以说明，使用lock的性能要好。

在《深入理解Java虚拟机》这本书上，作者说了这句话：与其说ReentrantLock性能好，还不如说synchronized还有很大优化的余地。在JDK1.6之后，人们发现synchronized与ReentrantLock的性能基本上是完全持平的(上面测试的JDK是1.8，不知道为什么没有持平)。虚拟机在未来的性能改进中肯定会更加偏向于原生的synchronized，所以还是提倡synchronized能实现需求的情况下，优先考虑使用synchronized来进行同步。

无论别人怎么说，测试才是王道。当确实synchroinzed同步时我们的性能瓶颈时，我们可以用ReentrantLock来进行性能的测试，如果确实更优，我们就可以选择用ReetrantLock来进行同步。

用Lock来进行同步计数和使用AtomicInteger类计数的性能比较

纯属好奇，刚好用Lock来模拟了下AtmoicInteger，因此，我也就比较了下这两个类在开启10个线程，每个线程计数到1000000的时间。

代码如下：

import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomicIntegerLock2 {

private static int synValue = 0;
public static void main(String[] args) {
int threadNum = 10;
int maxValue = 1000000;

Thread[] t = new Thread[threadNum];
Long begin = System.nanoTime();
for(int i=0;i<threadNum;i++){
AtomicIntegerLock aIL = new AtomicIntegerLock(0);
t[i]=new Thread(new Runnable(){

@Override
public void run() {
for(int j=0;j<maxValue;j++){
aIL.getAndIncrement();
}
}

});
}
for(int i=0;i<threadNum;i++){
t[i].start();
}
//main线程等待前面开启的所有线程结束
for(int i=0;i<threadNum;i++){
try {
t[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println("使用lock所花费的时间为："+(System.nanoTime()-begin));

int[] lock = new int[0];
begin = System.nanoTime();
for(int i=0;i<threadNum;i++){
AtomicInteger ai = new AtomicInteger(0);
t[i]=new Thread(new Runnable(){

@Override
public void run() {
for(int j=0;j<maxValue;j++){
ai.incrementAndGet();
}
}

});
}
for(int i=0;i<threadNum;i++){
t[i].start();
}
//main线程等待前面开启的所有线程结束
for(int i=0;i<threadNum;i++){
try {
t[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println("使用原子操作类AtomicInteger所花费的时间为："+(System.nanoTime()-begin));

}

}

运行结果如下：

使用lock所花费的时间为：493427269
使用原子操作类AtomicInteger所花费的时间为：85106267

可想可知，使用CAS指令确实更要快的多。