多线程学习--读写锁

柔情只为你懂 2024-02-19 14:38 56阅读 0赞

读写锁(ReentrantReadWriteLock)：具有互斥排他效果，即同一时间只有一个线程在执行锁后面的任务，这种效率比较搞。

读锁也称为共享锁，写锁也称为排他锁。多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个线程都可以获取读锁，而进行写入操作的线程只有在获取写锁后才能进行写入操作。

同一时刻只允许一个线程进行写入操作，多个线程可以同时进行读取操作。

案例：

读读共享：允许多个线程同时执行锁后面的代码。

class MyReadService {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public void read() {
            try {
                try {
                    lock.readLock().lock();
                    System.out.println("获得读锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.readLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public class test{
        public static void main(String[] args) {
            final MyReadService service = new MyReadService();
            Thread a = new Thread() {
                @Override
                public void run() {
                    service.read();
                }
            };
            Thread b = new Thread() {
                @Override
                public void run() {
                    service.read();
                }
            };
            a.setName("A");
            a.start();
            b.setName("B");
            b.start();
        }
    }

结果:

获得读锁B 1544782756369
    获得读锁A 1544782756369

写写互斥:同一时间只允许一个线程执行lock()方法后面的代码

class MyWriteService {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public void write() {
            try {
                try {
                    lock.writeLock().lock();
                    System.out.println("获得写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.writeLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public class test{
        public static void main(String[] args) {
            final MyWriteService service = new MyWriteService();
            Thread a = new Thread() {
                @Override
                public void run() {
                    service.write();
                }
            };
            Thread b = new Thread() {
                @Override
                public void run() {
                    service.write();
                }
            };
            a.setName("A");
            a.start();
            b.setName("B");
            b.start();
        }
    }

结果:

获得写锁B 1544782934185
    获得写锁A 1544782944185

读写互斥:

class Service3 {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public void read() {
            try {
                try {
                    lock.readLock().lock();
                    System.out.println("获得读锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.readLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void write() {
            try {
                try {
                    lock.writeLock().lock();
                    System.out.println("获得写锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.writeLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public class test{
        public static void main(String[] args) {
            final Service3 service = new Service3();
            Thread a = new Thread() {
                @Override
                public void run() {
                    service.read();
                }
            };
            Thread b = new Thread() {
                @Override
                public void run() {
                    service.write();
                }
            };
            a.setName("A");
            a.start();
            b.setName("B");
            b.start();
        }
    }

结果：

获得读锁 A 1544783060241
    获得写锁 B 1544783070242