并发控制(6)ReentrantLock 重入锁

柔光的暖阳◎ 2022-09-25 11:27 237阅读 0赞

### 并发控制(6)ReentrantLock 重入锁 ###

*  这个锁基本上概念和synchronized关键字用法很像，但是在实现上和使用上的稳定性上貌似比synchronized要好.
 *  但是你在调用锁的时候，要注意释放，不然就麻烦了。。。其他线程没有办法使用资源了
 *  下面有4个例子注意区别

--------------------

#### 有如下代码 ####

import java.util.concurrent.CopyOnWriteArrayList;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class UseReentrantLock { 
    
        private Lock lock = new ReentrantLock();
    
        public void method1(){
            try {
                lock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
                Thread.sleep(1000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
    
                lock.unlock();
            }
        }
    
        public void method2(){
            try {
                lock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
                Thread.sleep(2000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
    
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
            final UseReentrantLock ur = new UseReentrantLock();
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    ur.method1();
                    ur.method2();
                }
            }, "t1");
    
            t1.start();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //System.out.println(ur.lock.getQueueLength());
        }
    
    
    }

--------------------

#### 下面一个例子是使用condition的情况，这个比synchronized要灵活不少 ####

import java.util.concurrent.CopyOnWriteArrayList;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class UseCondition { 
    
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        public void method1(){
            try {
                lock.lock();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
                condition.await();  // Object wait
                System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void method2(){
            try {
                lock.lock();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
                condition.signal();     //Object notify
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
            final UseCondition uc = new UseCondition();
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    uc.method1();
                }
            }, "t1");
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    uc.method2();
                }
            }, "t2");
            t1.start();
    
            t2.start();
        }
    
    
    
    }

--------------------

#### 使用多个condition的情况，看看就可以了，其实很简单 ####

import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class UseManyCondition { 
    
        private ReentrantLock lock = new ReentrantLock();
        private Condition c1 = lock.newCondition();
        private Condition c2 = lock.newCondition();
    
        public void m1(){
            try {
                lock.lock();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
                c1.await();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void m2(){
            try {
                lock.lock();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
                c1.await();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void m3(){
            try {
                lock.lock();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
                c2.await();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void m4(){
            try {
                lock.lock();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
                c1.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public void m5(){
            try {
                lock.lock();
                System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
                c2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
    
            final UseManyCondition umc = new UseManyCondition();
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    umc.m1();
                }
            },"t1");
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    umc.m2();
                }
            },"t2");
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    umc.m3();
                }
            },"t3");
            Thread t4 = new Thread(new Runnable() {
                @Override
                public void run() {
                    umc.m4();
                }
            },"t4");
            Thread t5 = new Thread(new Runnable() {
                @Override
                public void run() {
                    umc.m5();
                }
            },"t5");
    
            t1.start(); // c1
            t2.start(); // c1
            t3.start(); // c2
    
    
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            t4.start(); // c1
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t5.start(); // c2
    
        }
    
    
    }

--------------------

#### 这是使用读写锁例子，看一下就可以了 ####

public class UseReentrantReadWriteLock { 
    
        private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        private ReadLock readLock = rwLock.readLock();
        private WriteLock writeLock = rwLock.writeLock();
    
        public void read(){
            try {
                readLock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
                Thread.sleep(3000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
            }
        }
    
        public void write(){
            try {
                writeLock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
                Thread.sleep(3000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                writeLock.unlock();
            }
        }
    
        public static void main(String[] args) {
    
            final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t1");
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t2");
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.write();
                }
            }, "t3");
            Thread t4 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.write();
                }
            }, "t4");       
    
    // t1.start();
    // t2.start();
    
    // t1.start(); // R 
    // t3.start(); // W
    
            t3.start();
            t4.start();