(Java 高并发程序设计) 一篇文章带你深入了解多线程中的信号量（Semaphore）和读写锁(ReadWriteLock)

太过爱你忘了你带给我的痛 2022-12-22 08:55 150阅读 0赞

### 文章目录 ###

*   *  一、允许多个线程同时访问：信号量（Semaphore）
     *  二、ReadWriteLock 读写锁

## 一、允许多个线程同时访问：信号量（Semaphore） ##

信号量为多线程协作提供了更为强大的控制方法。从广义上说，信号量是对锁的扩展。无论是内部锁`synchronized`还是重入锁`ReentrantLock`，一次都只允许一个线程访问一个资源，而信号量却可以指定多个线程，同时访问某一个资源。信号量主要提供了以下构造函数：

public Semaphore(int permits)
    public Semaphore(int permits,boolean fair)//第二个参数可以指定是否公平

在构造信号量对象时，必须要指定信号量的准入数，即同时能申请多少个许可。当每个线程每次只申请一个许可时，这就相当于指定了同时有多少个线程可以访问某一个资源。信号量的主要逻辑方法有：

![在这里插入图片描述][20201118210112444.png_pic_center]  
`acquire()`方法尝试获得一个准入的许可。若无法获得，则线程会等待，直到有线程释放一个许可或者当前线程被中断。`acquireUninterruptibly()`方法和`acquire()`方法类似，但是不响应中断。`tryAcquire()`方法尝试获得一个许可，如果成功则返回true，失败则返回false，它不会进行等待，立即返回。`release()`方法用于在线程访问资源结束后释放一个许可，以使其他等待许可的线程可以进行资源访问。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    
    public class SemapDemo implements Runnable { 
        //5个一组输出
        final Semaphore semp = new Semaphore(5);
    
        @Override
        public void run() { 
            try { 
                //申请信号量
                semp.acquire();
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getId() + " done!");
                //释放信号量
                semp.release();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        public static void main(String []args){ 
            ExecutorService exec = Executors.newFixedThreadPool(20);
            final SemapDemo demo = new SemapDemo();
            for(int i=0;i<20;i++){ 
                exec.submit(demo);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]  
同时开启20个线程。观察这段程序的输出，你就会发现系统以5个线程一组为单位，依次输出带有线程ID的提示文本。

## 二、ReadWriteLock 读写锁 ##

`ReadWriteLock`是JDK 5中提供的读写分离锁。读写分离锁可以有效地帮助减少锁竞争，提升系统性能。用锁分离的机制来提升性能非常容易理解，比如线程A1、A2、A3进行写操作，B1、B2、B3进行读操作，如果使用重入锁或者内部锁，从理论上说所有读之间、读与写之间、写和写之间都是串行操作。当B1进行读取时，B2、B3则需要等待锁。由于读操作并不对数据的完整性造成破坏，这种等待显然是不合理的。因此，读写锁就有了发挥功能的余地。

在这种情况下，读写锁允许多个线程同时读，使得B1、B2、B3之间真正并行。但是，考虑到数据完整性，写写操作和读写操作间依然是需要相互等待和持有锁的。总的来说，读写锁的访问约束情况如表3.1所示。

![在这里插入图片描述][20201119200459799.png_pic_center]  
如果在系统中，读操作的次数远远大于写操作的次数，则读写锁就可以发挥最大的功效，提升系统的性能。这里我给出一个稍微夸张点的案例来说明读写锁对性能的帮助。

import java.util.Random;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class ReadWriteLockDemo { 
        private static Lock lock = new ReentrantLock();
        private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        private static Lock readLock = readWriteLock.readLock();
        private static Lock writeLock = readWriteLock.writeLock();
        private int value;
    
        public Object handleRead(Lock lock) throws InterruptedException { 
            try { 
                lock.lock();
                //读耗时
                Thread.sleep(1000);
                System.out.println("read success");
                return value;
            } finally { 
                lock.unlock();
            }
        }
        public void handleWrite(Lock lock, int index) throws InterruptedException { 
            try { 
                lock.lock();
                //写耗时
                Thread.sleep(1000);
                value = index;
                System.out.println("write success");
            } finally { 
                lock.unlock();
            }
        }
        public static void main(String[] args) { 
            final ReadWriteLockDemo demo = new ReadWriteLockDemo();
            Runnable readRunnable = new Runnable() { 
                @Override
                public void run() { 
                    try { 
                       // 使用读锁
                       demo.handleRead(readLock);
                        // demo.handleRead(lock);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            };
            Runnable writeRunnable = new Runnable() { 
                @Override
                public void run() { 
                    try { 
                       // 使用写锁
                       demo.handleWrite(writeLock, new Random().nextInt());
                        // demo.handleWrite(lock, new Random().nextInt());
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            };
            for (int i = 0; i < 18; i++) { 
                new Thread(readRunnable).start();
            }
            for (int i = 18; i < 20; i++) { 
                new Thread(writeRunnable).start();
            }
        }
    }

由于这里使用了读写分离，因此，读线程完全并行，而写会阻塞读，因此，实际上这段代码运行大约2秒多就能结束（写线程之间实际是串行的）。而如果使用第35行代替第34行，使用第46行代替第45行执行上述代码，即使用普通的重入锁代替读写锁，所有的读和写线程之间也都必须相互等待，因此整个程序的执行时间将长达20余秒。

[20201118210112444.png_pic_center]: /images/20221120/7d0064f24b8740389ebe79760a3c9e79.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/9da0399c0f404f1a9c6eff2de5f02afa.png
[20201119200459799.png_pic_center]: /images/20221120/20dc4b05948d491cbaf88381260e1a80.png