java.util.concurrent提供了显式的互斥锁机制，允许一些更细腻化的锁操作。我们需要显式创建一个互斥锁对象ReentrantLock。
    下面的示例中，线程尝试获取锁，如果获取失败，可以离开去执行一些事情：

1. import java.util.concurrent.TimeUnit;
   
2. import java.util.concurrent.locks.ReentrantLock;
   
3. 
   
4. public class LockDemo {
   
5.         //显式创建互斥锁
   
6.         private ReentrantLock lock = new ReentrantLock();
   
7.        
   
8.         public void f(){
   
9.                 //tryLock尝试获取锁，如果成功将立即返回true，反之false
   
10.                 boolean captured = lock.tryLock();
    
11.                
    
12.                 try {
    
13.                         System.out.println("f() " + captured);
    
14.                 } finally {
    
15.                         if(captured)
    
16.                                 lock.unlock();
    
17.                 }
    
18.         }
    
19.        
    
20.         public void g(){
    
21.                 boolean captured = false;
    
22.                
    
23.                 try {
    
24.                         //在3秒内不断尝试获取锁
    
25.                         captured = lock.tryLock(2, TimeUnit.SECONDS);
    
26.                 } catch (InterruptedException e) {
    
27.                         throw new RuntimeException(e);
    
28.                 }
    
29.                
    
30.                 try {
    
31.                         System.out.println("g() " + captured);
    
32.                 } finally {
    
33.                         if(captured)
    
34.                                 lock.unlock();
    
35.                 }
    
36.         }
    
37.        
    
38.         public static void main(String[] args) {
    
39.                 final LockDemo ld = new LockDemo();
    
40.                 //测试顺序情况下是否正常
    
41.                 ld.f();
    
42.                 ld.g();
    
43.                
    
44.                 //测试并发情况下是否正常
    
45.                 new Thread(){
    
46.                         //设为守护线程
    
47.                         { setDaemon(true); }
    
48.                         public void run(){
    
49.                                 //lock虽然是private域但是它比较特殊，对外可见
    
50.                                 ld.lock.lock();
    
51.                                 System.out.println("Thread");
    
52.                         }
    
53.                 }.start();
    
54.                
    
55.                 //建议调度
    
56.                 Thread.yield();
    
57.                
    
58.                 //这些方法在匿名线程持有锁的时候尝试获取锁
    
59.                 ld.f();
    
60.                 ld.g();
    
61.         }
    
62. }

复制代码

java.util.concurrent提供了显式的互斥锁机制，允许一些更细腻化的锁操作。我们需要显式创建一个互斥锁对象ReentrantLock。
    下面的示例中，线程尝试获取锁，如果获取失败，可以离开去执行一些事情：

1. import java.util.concurrent.TimeUnit;
   
2. import java.util.concurrent.locks.ReentrantLock;
   
3. 
   
4. public class LockDemo {
   
5.         //显式创建互斥锁
   
6.         private ReentrantLock lock = new ReentrantLock();
   
7.        
   
8.         public void f(){
   
9.                 //tryLock尝试获取锁，如果成功将立即返回true，反之false
   
10.                 boolean captured = lock.tryLock();
    
11.                
    
12.                 try {
    
13.                         System.out.println("f() " + captured);
    
14.                 } finally {
    
15.                         if(captured)
    
16.                                 lock.unlock();
    
17.                 }
    
18.         }
    
19.        
    
20.         public void g(){
    
21.                 boolean captured = false;
    
22.                
    
23.                 try {
    
24.                         //在3秒内不断尝试获取锁
    
25.                         captured = lock.tryLock(2, TimeUnit.SECONDS);
    
26.                 } catch (InterruptedException e) {
    
27.                         throw new RuntimeException(e);
    
28.                 }
    
29.                
    
30.                 try {
    
31.                         System.out.println("g() " + captured);
    
32.                 } finally {
    
33.                         if(captured)
    
34.                                 lock.unlock();
    
35.                 }
    
36.         }
    
37.        
    
38.         public static void main(String[] args) {
    
39.                 final LockDemo ld = new LockDemo();
    
40.                 //测试顺序情况下是否正常
    
41.                 ld.f();
    
42.                 ld.g();
    
43.                
    
44.                 //测试并发情况下是否正常
    
45.                 new Thread(){
    
46.                         //设为守护线程
    
47.                         { setDaemon(true); }
    
48.                         public void run(){
    
49.                                 //lock虽然是private域但是它比较特殊，对外可见
    
50.                                 ld.lock.lock();
    
51.                                 System.out.println("Thread");
    
52.                         }
    
53.                 }.start();
    
54.                
    
55.                 //建议调度
    
56.                 Thread.yield();
    
57.                
    
58.                 //这些方法在匿名线程持有锁的时候尝试获取锁
    
59.                 ld.f();
    
60.                 ld.g();
    
61.         }
    
62. }

复制代码