深入浅出 java concurrency (6): 锁机制 part 1 -凯发k8网页登录

前面的章节主要谈谈原子操作，至于与原子操作一些相关的问题或者说陷阱就放到最后的总结篇来整体说明。从这一章开始花少量的篇幅谈谈锁机制。

上一个章节中谈到了锁机制，并且针对于原子操作谈了一些相关的概念和设计思想。接下来的文章中，尽可能的深入研究锁机制，并且理解里面的原理和实际应用场合。

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

jdk 5中的锁是接口java.util.concurrent.locks.lock。另外java.util.concurrent.locks.readwritelock提供了一对可供读写并发的锁。根据前面的规则，我们从java.util.concurrent.locks.lock的api开始。

void lock();

获取锁。

如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。

void lockinterruptibly() throws interruptedexception;

如果当前线程未被中断，则获取锁。

如果锁可用，则获取锁，并立即返回。

如果锁不可用，出于线程调度目的，将禁用当前线程，并且在发生以下两种情况之一以前，该线程将一直处于休眠状态：

• 锁由当前线程获得；或者
• 其他某个线程当前线程，并且支持对锁获取的中断。

如果当前线程：

• 在进入此方法时已经设置了该线程的中断状态；或者
• 在获取锁时被，并且支持对锁获取的中断，

condition newcondition();

返回绑定到此 lock 实例的新 condition 实例。下一小节中会重点谈condition，此处不做过多的介绍。

boolean trylock();

仅在调用时锁为空闲状态才获取该锁。

如果锁可用，则获取锁，并立即返回值 true。如果锁不可用，则此方法将立即返回值 false。

通常对于那些不是必须获取锁的操作可能有用。

boolean trylock(long time, timeunit unit) throws interruptedexception;

如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。

如果锁可用，则此方法将立即返回值 true。如果锁不可用，出于线程调度目的，将禁用当前线程，并且在发生以下三种情况之一前，该线程将一直处于休眠状态：

• 锁由当前线程获得；或者
• 其他某个线程中断当前线程，并且支持对锁获取的中断；或者
• 已超过指定的等待时间

如果获得了锁，则返回值 true。

如果当前线程：

• 在进入此方法时已经设置了该线程的中断状态；或者
• 在获取锁时被中断，并且支持对锁获取的中断，

如果超过了指定的等待时间，则将返回值 false。如果 time 小于等于 0，该方法将完全不等待。

void unlock();

释放锁。对应于lock()、trylock()、trylock(xx)、lockinterruptibly()等操作，如果成功的话应该对应着一个unlock()，这样可以避免死锁或者资源浪费。

相对于比较空洞的api，来看一个实际的例子。下面的代码实现了一个类似于atomicinteger的操作。

package xylz.study.concurrency.lock;

import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;

public class atomicintegerwithlock {

    private int value;

    private lock lock = new reentrantlock();

    public atomicintegerwithlock() {
        super();
    }

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

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

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

    }

    public final int getandset(int newvalue) {
        lock.lock();
        try {
            int ret = value;
            value = newvalue;
            return ret;
        } finally {
            lock.unlock();
        }
    }

    public final boolean compareandset(int expect, int update) {
        lock.lock();
        try {
            if (value == expect) {
                value = update;
                return true;
            }
            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 string tostring() {
        return integer.tostring(get());
    }
}

类atomicintegerwithlock是线程安全的，此结构中大量使用了lock对象的lock/unlock方法对。同样可以看到的是对于自增和自减操作使用了 /--。之所以能够保证线程安全，是因为lock对象的lock()方法保证了只有一个线程能够只有此锁。需要说明的是对于任何一个lock()方法，都需要一个unlock()方法与之对于，通常情况下为了保证unlock方法总是能够得到执行，unlock方法被置于finally块中。另外这里使用了java.util.concurrent.locks.reentrantlock.reentrantlock对象，下一个小节中会具体描述此类作为lock的唯一实现是如何设计和实现的。

尽管synchronized实现lock的相同语义，并且在语法上比lock要简单多，但是前者却比后者的开销要大得多。做一个简单的测试。

public static void main(string[] args) throws exception{
     final int max = 10;
     final int loopcount = 100000;
     long costtime = 0;
     for (int m = 0; m < max; m ) {
         long start1 = system.nanotime();
         final atomicintegerwithlock value1 = new atomicintegerwithlock(0);
         thread[] ts = new thread[max];
         for(int i=0;i              ts[i] = new thread() {
                 public void run() {
                     for (int i = 0; i < loopcount; i ) {
                         value1.incrementandget();
                     }
                 }
             };
         }
         for(thread t:ts) {
             t.start();
         }
         for(thread t:ts) {
             t.join();
         }
         long end1 = system.nanotime();
         costtime = (end1-start1);
     }
     system.out.println("cost1: " (costtime));
     //
     system.out.println();
     costtime = 0;
     //
     final object lock = new object();
     for (int m = 0; m < max; m ) {
         staticvalue=0;
         long start1 = system.nanotime();
         thread[] ts = new thread[max];
         for(int i=0;i              ts[i] = new thread() {
                 public void run() {
                     for (int i = 0; i < loopcount; i ) {
                         synchronized(lock) {
                             staticvalue;
                         }
                     }
                 }
             };
         }
         for(thread t:ts) {
             t.start();
         }
         for(thread t:ts) {
             t.join();
         }
         long end1 = system.nanotime();
         costtime = (end1-start1);
     }
     //
     system.out.println("cost2: " (costtime));
}

static int staticvalue = 0;

 

在这个例子中每次启动10个线程，每个线程计算100000次自增操作，重复测试10次，下面是某此测试的结果：

cost1: 624071136

cost2: 2057847833

尽管上面的例子不是非常正式的测试案例，但上面的例子在于说明，lock的性能比synchronized的要好得多。如果可以的话总是使用lock替代synchronized是一个明智的选择。