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方法获取和释放对象锁达到同步调用的效果。