Java多线程编程中线程锁与读写锁的使用示例

时间:2022-04-19 07:49:27

线程锁Lock
Lock  相当于 当前对象的 Synchronized

?
1
2
3
4
5
6
7
8
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
 * Lock lock = new ReentrantLock();
 * lock.lock();  lock.unLock();
 * 类似于 synchronized,但不能与synchronized 混用
 */
public class LockTest {
  public static void main(String[] args) {
    final Outer outer = new LockTest().new Outer();
    new Thread(new Runnable() {
 
      @Override
      public void run() {
        // TODO Auto-generated method stub
        while (true) {
          outer.out1("zhangxiaoxiao");
          outer.out2("lihuoming");
        }
      }
 
    }).start();
    new Thread(new Runnable() {
 
      @Override
      public void run() {
        // TODO Auto-generated method stub
        while (true) {
          outer.out1("zhangxiaoxiao");
          outer.out2("lihuoming");
        }
      }
 
    }).start();
 
  }
  class Outer {
    Lock lock = new ReentrantLock();
    void out1(String name) {
      lock.lock();
      int len = name.length();
      for (int i = 0; i < len; i++) {
        System.out.print(name.charAt(i));
      }
      System.out.println();
      lock.unlock();
    }
    void out2(String name) {
      lock.lock();
      int len = name.length();
      for (int i = 0; i < len; i++) {
        System.out.print(name.charAt(i));
      }
      System.out.println();
      lock.unlock();
    }
  }
}


读写锁 ReentrantReadWriteLock

 读写锁:允许多条线程同时读;不能读中有写;不能写中有读;不能写中有写

?
1
2
3
4
5
6
7
8
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
34
35
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*
 * 问题:设计一个 缓存机制 的 伪代码
 *  从集合中读取数据,读取不到,就写入,再考虑多线程并发的情况 
 */
public class ReadWriteLockTest2 {
  private Map<String, Object> data = new HashMap<String, Object>();
  private ReadWriteLock lock = new ReentrantReadWriteLock(); 
  //读写锁
  public Object getInstance1(String key, Object obj) {
    lock.readLock().lock();
    Object value = null;
    try {
      value = data.get(key);
      if (value == null) {//一条线程进入这里,
        lock.readLock().unlock();//读锁解了,其他线程就可能也到这了
        lock.writeLock().lock();//只能有一条线程到这,写锁开启,要写入数据了
        if (data.get(key) == null) {
          value = obj;  
            /*先判断数据,如果不存在,才写入,,因为 界时当写锁解除后,其他
              线程,再想写入时, 判断到数据存在 ,就跳过了。就不会发生同时写入的情况
            */   
          data.put(key, value); 
        }
        lock.writeLock().unlock();//写完了,解锁
        lock.readLock().lock();
      }
    } finally {
      lock.readLock().unlock();
    }  
    return value;
  }