Java多线程之并发锁

这是自JDK5.0开始提供的Java并发包里面的类

下面是关于Java并发锁的测试代码

1. package com.jadyer.thread.lock;  
2.   
3. import java.util.concurrent.locks.Lock;  
4. import java.util.concurrent.locks.ReentrantLock;  
5.   
6. /** 
7.  * LockTest 
8.  * @author 宏宇 
9.  * @create Mar 1, 2012 7:12:04 PM 
10.  */  
11. public class LockTest {  
12.     public static void main(String[] args) {  
13.         FoodCenter fc = new FoodCenter();  
14.         new Thread(new ThreadDog(fc, "It is dog`s food")).start();  
15.         new Thread(new ThreadPig(fc, "It is pig`s food")).start();  
16.     }  
17. }  
18.   
19.   
20. class ThreadDog implements Runnable{  
21.     private FoodCenter fc;  
22.     private String foodname;  
23.     public ThreadDog(FoodCenter fc, String foodname){  
24.         this.fc = fc;  
25.         this.foodname = foodname;  
26.     }  
27.     @Override  
28.     public void run() {  
29.         while(true){  
30.             try {  
31.                 Thread.sleep(1000);  
32.             } catch (InterruptedException e) {  
33.                 e.printStackTrace();  
34.             }  
35.             fc.getFood(foodname);  
36.         }  
37.     }  
38. }  
39.   
40.   
41. class ThreadPig implements Runnable{  
42.     private FoodCenter fc;  
43.     private String foodname;  
44.     public ThreadPig(FoodCenter fc, String foodname){  
45.         this.fc = fc;  
46.         this.foodname = foodname;  
47.     }  
48.     @Override  
49.     public void run() {  
50.         while(true){  
51.             try {  
52.                 Thread.sleep(2000);  
53.             } catch (InterruptedException e) {  
54.                 e.printStackTrace();  
55.             }  
56.             fc.getFood(foodname);  
57.         }  
58.     }  
59. }  
60.   
61.   
62. /** 
63.  * @see ========================================================================================= 
64.  * @see java.util.concurrent是JDK5.0开始提供的Java并发包，其子包locks是专门用于处理线程锁的 
65.  * @see java.util.concurrent.locks.Lock较synchronized关键字比，有一个最大的区别，那就是 
66.  * @see Lock可以比synchronized更细粒度的控制锁，体现在try{...}finally{mylock.unlock();} 
67.  * @see ========================================================================================= 
68.  * @see Lock有点像公共厕所的门闩，只有正在使用厕所的人，把门闩打开出来了，其它人才可以使用公厕 
69.  * @see Lock比传统线程模型中的synchronized方式更加面向对象。与生活中的锁类似，锁本身也应该是一个对象 
70.  * @see 两个线程执行的代码片段要实现同步互斥的效果，那么这两个线程所使用的必须是同一个Lock对象 
71.  * @see 并且，锁应该位于待操作的资源类的内部方法中，而非线程代码中 
72.  * @see ========================================================================================= 
73.  */  
74. class FoodCenter {  
75.     Lock mylock = new ReentrantLock(); //创建一个锁   
76.     public void getFood(String name) {  
77.         int len = name.length();  
78.         mylock.lock(); //上锁   
79.         try {  
80.             for (int i = 0; i < len; i++) {  
81.                 System.out.print(name.charAt(i));  
82.             }  
83.             System.out.println();  
84.         } finally {  
85.             mylock.unlock(); //解锁   
86.         }  
87.     }  
88. }  

下面是关于Java读写锁的测试代码

1. package com.jadyer.thread.lock;  
2.   
3. import java.util.concurrent.locks.ReadWriteLock;  
4. import java.util.concurrent.locks.ReentrantReadWriteLock;  
5.   
6. /** 
7.  * Java读写锁 
8.  * @see 锁分为读锁和写锁。多个读锁不互斥。读锁与写锁互斥。写锁与写锁互斥。这是由JVM自己控制的 
9.  * @see 如果代码只读数据，可以很多人同时读，但不能同时写，那就上读锁 
10.  * @see 如果代码修改数据，并且不允许同时读，只能一个人写，那就上写锁 
11.  * @see 总之：读的时候上读锁，写的时候上写锁 
12.  */  
13. public class ReadWriteLockDemo{  
14.     private Object myData = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据   
15.     ReadWriteLock rwl = new ReentrantReadWriteLock();  
16.   
17.     public void get() {  
18.         rwl.readLock().lock(); //读锁   
19.         try {  
20.             System.out.println(Thread.currentThread().getName() + " be ready to read data");  
21.             Thread.sleep((long) (Math.random() * 1000));  
22.             System.out.println(Thread.currentThread().getName() + " have read data : " + myData);  
23.         } catch (InterruptedException e) {  
24.             e.printStackTrace();  
25.         } finally {  
26.             rwl.readLock().unlock();  
27.         }  
28.     }  
29.   
30.     public void put(Object data) {  
31.         rwl.writeLock().lock(); //写锁   
32.         try {  
33.             System.out.println(Thread.currentThread().getName() + " be ready to write data");  
34.             Thread.sleep((long) (Math.random() * 1000));  
35.             this.myData = data;  
36.             System.out.println(Thread.currentThread().getName() + " have write data : " + myData);  
37.         } catch (InterruptedException e) {  
38.             e.printStackTrace();  
39.         } finally {  
40.             rwl.writeLock().unlock();  
41.         }  
42.     }  
43. }