Java并发包的其他锁：信号量，读写锁，倒计数器，循环栅栏

1：信号量：允许多个线程同时访问

• 可以指定能同时访问资源的线程的个数
• 构造函数Semaphore(int permits) 创建具有给定的许可数和非公平的公平设置的 Semaphore。
• 支持公平锁：Semaphore(int permits, boolean fair) 创建具有给定的许可数和给定的公平设置的 Semaphore。
  

import java.util.Scanner;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
   

    public static void main(String[] args) throws InterruptedException {
   
        th tt=new th();
        Thread t1=new Thread(tt,"t1");
        Thread t2=new Thread(tt,"t2");
        Thread t3=new Thread(tt,"t3");
        Thread t4=new Thread(tt,"t4");
        Thread t5=new Thread(tt,"t5");
        t1.start();t2.start();
        t3.start();t4.start();
        t5.start();
        
    }
}

class th implements Runnable{
   
     Semaphore semaphore=new Semaphore(3);

    @Override
    public void run() {
   
        try {
   
            semaphore.acquire();

            System.out.println(Thread.currentThread().getName()+"在做一些工作");
            Thread.sleep(3000);
            //semaphore.release(); 因为有sleep收益不要放在这里
        } catch (InterruptedException e) {
   
            e.printStackTrace();
            System.out.println("发生中断");
        }finally {
   
            semaphore.release();
        }


    }

}
--------
t2在做一些工作
t3在做一些工作
t1在做一些工作
//显示上三个基本来纳许打印，然后是后面的
t5在做一些工作
t4在做一些工作

该实例同时允许三个线程访问共享资源/代码块

2：读写锁：ReadWriteLock

• 读-读不会阻塞
• 其他三种情况都会阻塞

2.1：构造方法

 ReadWriteLock readWriteLock=new ReentrantReadWriteLock();

2.2：获得读锁与写锁

 ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
    Lock readLock=readWriteLock.readLock