Lock接口的使用

在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在jdk1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩张功能上也更加强大，使用上也比synchronized更加的灵活。

示例代码：

// class Service01
public class Service01 {

    private Lock lock = new ReentrantLock();

    public void testMethod() {
        lock.lock();
        for(int i = 0; i < 3; ++ i) {
            System.out.println("ThreadName=" + Thread.currentThread().getName()
                    + (" " + (i + 1)));
        }
        lock.unlock();
    }
}
// class Thread01
public class Thread01 extends Thread {
    private Service01 service;

    public Thread01(Service01 service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}
// class Main
public class Main {

    public static void main(String[] args) {
        thread01();
    }

    private static void thread01() {
        Service01 service = new Service01();
        Thread01 t1 = new Thread01(service);
        Thread01 t2 = new Thread01(service);
        Thread01 t3 = new Thread01(service);
        Thread01 t4 = new Thread01(service);
        Thread01 t5 = new Thread01(service);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

输出结果：

ThreadName=Thread-0 1
ThreadName=Thread-0 2
ThreadName=Thread-0 3
ThreadName=Thread-1 1
ThreadName=Thread-1 2
ThreadName=Thread-1 3
ThreadName=Thread-2 1
ThreadName=Thread-2 2
ThreadName=Thread-2 3
ThreadName=Thread-4 1
ThreadName=Thread-4 2
ThreadName=Thread-4 3
ThreadName=Thread-3 1
ThreadName=Thread-3 2
ThreadName=Thread-3 3

从输出的结果中我们可以看到启动的5个线程在调用Service01对象的testMethod()方法时是同步调用的，并没有使用synchronized获取对象锁的方式实现同步调用，而是使用了更加灵活的Lock接口类型的lock和unlock方法获取和释放对象锁达到同步调用的效果。