转发 ：java线程：互斥锁与读写锁

原文链接：http://coolxing.iteye.com/blog/1236909

两种互斥锁机制：

1、synchronized

2、ReentrantLock

ReentrantLock是jdk5的新特性，采用ReentrantLock可以完全替代替换synchronized传统的锁机制，而且采用ReentrantLock的方式更加面向对象，也更加灵活，网上有很多关于对比两者锁方式的文章，这里就不多口舌了，大家baidu、google一下就水落石出了。在本博客中也写关于这两种锁方式实现的经典例子《生产者消费者》。

synchronized方式：《java线程：三种方式实现生产者消费者问题_1》

ReentranLock方式：《java线程：三种方式实现生产者消费者问题_2》

关于读写锁，用语言解释不如直接用代码诠释，以下通过两个例子讲述读写锁以及读写锁的使用：

例子1：

[java] view plaincopy

1. import java.util.HashMap;
2. import java.util.Map;
3. import java.util.concurrent.locks.ReadWriteLock;
4. import java.util.concurrent.locks.ReentrantReadWriteLock;
5. /**
6. * @author amber2012
7. *
8. * 读写锁：ReadWriteLock
9. *
10. * 在多线程的环境下，对同一份数据进行读写，会涉及到线程安全的问题。比如在一个线程读取数据的时候，另外一个线程在
11. * 写数据，而导致前后数据的不一致性；一个线程在写数据的时候，另一个线程也在写，同样也会导致线程前后看到的数据的
12. * 不一致性。
13. *
14. * 这时候可以在读写方法中加入互斥锁，任何时候只能允许一个线程的一个读或写操作，而不允许其他线程的读或写操作，这
15. * 样是可以解决这样以上的问题，但是效率却大打折扣了。因为在真实的业务场景中，一份数据，读取数据的操作次数通常高
16. * 于写入数据的操作，而线程与线程间的读读操作是不涉及到线程安全的问题，没有必要加入互斥锁，只要在读-写，写-写期
17. * 间上锁就行了。
18. *
19. * 对于这种情况，读写锁则最好的解决方案！
20. *
21. * 读写锁的机制：
22. *      "读-读"不互斥
23. *      "读-写"互斥
24. *      "写-写"互斥
25. *
26. * 即在任何时候必须保证：
27. *      只有一个线程在写入；
28. *      线程正在读取的时候，写入操作等待；
29. *      线程正在写入的时候，其他线程的写入操作和读取操作都要等待；
30. *
31. * 以下是一个缓存类：用于演示读写锁的操作：重入、降级
32. */
33. public class CachedData {
34. // 缓存都应该是单例的，在这里用单例模式设计：
35. private static CachedData cachedData = new CachedData();
36. private final ReadWriteLock lock = new ReentrantReadWriteLock();//读写锁
37. private Map<String, Object> cache = new HashMap<String, Object>();//缓存
38. private CachedData(){
39. }
40. public static CachedData getInstance(){
41. return cachedData;
42. }
43. // 读取缓存：
44. public Object read(String key) {
45. lock.readLock().lock();
46. Object obj = null;
47. try {
48. obj = cache.get(key);
49. if (obj == null) {
50. lock.readLock().unlock();
51. // 在这里的时候，其他的线程有可能获取到锁
52. lock.writeLock().lock();
53. try {
54. if (obj == null) {
55. obj = "查找数据库"; // 实际动作是查找数据库
56. // 把数据更新到缓存中：
57. cache.put(key, obj);
58. }
59. } finally {
60. // 当前线程在获取到写锁的过程中，可以获取到读锁，这叫锁的重入，然后导致了写锁的降级，称为降级锁。
61. // 利用重入可以将写锁降级，但只能在当前线程保持的所有写入锁都已经释放后，才允许重入 reader使用
62. // 它们。所以在重入的过程中，其他的线程不会有获取到锁的机会（这样做的好处）。试想，先释放写锁，在
63. // 上读锁，这样做有什么弊端？--如果这样做，那么在释放写锁后，在得到读锁前，有可能被其他线程打断。
64. // 重入————>降级锁的步骤：先获取写入锁，然后获取读取锁，最后释放写入锁（重点）
65. lock.readLock().lock();
66. lock.writeLock().unlock();
67. }
68. }
69. } finally {
70. lock.readLock().unlock();
71. }
72. return obj;
73. }
74. }

例子2：

[java] view plaincopy

1. import java.util.Map;
2. import java.util.TreeMap;
3. import java.util.concurrent.locks.Lock;
4. import java.util.concurrent.locks.ReadWriteLock;
5. import java.util.concurrent.locks.ReentrantReadWriteLock;
6. import javax.xml.crypto.Data;
7. /**
8. * @author amber2012
9. *
10. * jdk文档中关于ReentrantReadWriteLock类使用的一个很好的例子，以下是具体的介绍：
11. *
12. * 在使用某些种类的 Collection 时，可以使用 ReentrantReadWriteLock 来提高并发性。通常，在预期 collection
13. * 很大，读取者线程访问它的次数多于写入者线程，并且 entail 操作的开销高于同步开销时，这很值得一试。例如，以下
14. * 是一个使用 TreeMap 的类，预期它很大，并且能被同时访问。
15. */
16. public class RWDictionary {
17. private final Map<String, Data> map = new TreeMap<String, Data>();
18. private final ReadWriteLock rwl = new ReentrantReadWriteLock();
19. private final Lock readLock = rwl.readLock();
20. private final Lock writeLock = rwl.writeLock();
21. public Data get(String key) {
22. readLock.lock();
23. try {
24. return map.get(key);
25. } finally {
26. readLock.unlock();
27. }
28. }
29. public String[] allKeys() {
30. readLock.lock();
31. try {
32. return (String[]) map.keySet().toArray();
33. } finally {
34. readLock.unlock();
35. }
36. }
37. public Data put(String key, Data value) {
38. writeLock.lock();
39. try {
40. return map.put(key, value);
41. } finally {
42. writeLock.unlock();
43. }
44. }
45. public void clear() {
46. writeLock.lock();
47. try {
48. map.clear();
49. } finally {
50. writeLock.unlock();
51. }
52. }
53. }