多线程编程（七）锁Lock

妖狐艹你老母 2022-12-21 06:16 152阅读 0赞

# 锁Lock #

### 目录 ###

*  锁Lock
 *   *  1. 两大锁接口
     *  2. 可重入锁
     *  3. 读写锁

## 1. 两大锁接口 ##

*  Lock：支持重入、公平等锁的规则，实现类：ReentrantLock，ReadLock,WriteLock
 *  ReadWriteLock ：接口定义读取者共享，写入者独占的锁，实现类：ReentrantReadWriteLock

## 2. 可重入锁 ##

*  不可重入锁：即线程请求他已经拥有的锁时会阻塞
 *  可重入锁：即线程可以进入他已经拥有的锁的同步代码块

> 测试代码

public class ReentrantLockTest { 
    
        static ReentrantLock lock = new ReentrantLock();
    
        public static void main(String[] args) { 
            for (int i = 0; i < 10; i++) { 
                lock.lock();
                System.out.println("加锁次数" + i);
            }
    
            for (int i = 0; i < 10; i++) { 
                try { 
                    System.out.println("解锁次数" + i);
                } finally { 
                    lock.unlock();
                }
            }
        }
    }

> 测试结果

加锁次数0
    加锁次数1
    加锁次数2
    加锁次数3
    加锁次数4
    加锁次数5
    加锁次数6
    加锁次数7
    加锁次数8
    加锁次数9
    解锁次数0
    解锁次数1
    解锁次数2
    解锁次数3
    解锁次数4
    解锁次数5
    解锁次数6
    解锁次数7
    解锁次数8
    解锁次数9

## 3. 读写锁 ##

*  既可以同时读，读的时候不能写，
 *  不能同时写，写的时候不能读

> 测试代码

public class ReadWriteLockTest { 
    
        //要访问的对象
        private Map<String, String> map = new HashMap<>();
    
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
    
    
        public String get(String key) { 
    
            try { 
                readLock.lock();
                System.out.println(Thread.currentThread().getName() + "线程读锁已加锁");
                Thread.sleep(3000);
                return map.get(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            } finally { 
                readLock.unlock();
                System.out.println(Thread.currentThread().getName() + "线程读锁已解锁");
            }
        }
    
    
        public void put(String key, String value) { 
    
            try { 
                readLock.lock();
                System.out.println(Thread.currentThread().getName() + "线程写锁已加锁");
                Thread.sleep(3000);
                map.put(key, value);
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readLock.unlock();
                System.out.println(Thread.currentThread().getName() + "线程写锁已解锁");
            }
        }
    
    
        public static void main(String[] args) { 
            ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
            readWriteLockTest.put("key1", "value1");
    
            for (int i = 0; i < 5; i++) { 
    
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        readWriteLockTest.get("key1");
                    }
                }).start();
    
            }
        }
    }

> 测试结果

main线程写锁已加锁
    main线程写锁已解锁
    Thread-0线程读锁已加锁
    Thread-1线程读锁已加锁
    Thread-2线程读锁已加锁
    Thread-3线程读锁已加锁
    Thread-4线程读锁已加锁
    Thread-0线程读锁已解锁
    Thread-3线程读锁已解锁
    Thread-4线程读锁已解锁
    Thread-1线程读锁已解锁
    Thread-2线程读锁已解锁

> 结论 读锁都是在写锁之后执行