Semaphore信号量和读写锁ReadWriteLock

Semaphore 应用场景可以用在秒杀限流上。

需要注意的是它和线程池是不一样的,线程池规定了线程数量,但是Semaphore不限定线程数量,

在某一时刻只允许与自定义设定的信号数相同的线程来访问,等到线程执行完释放了信号其它线程才可以访问。

/***
 * 应用场景:限流
 */
public class TestSemaphore {

    public static void main(String[] args) {

        Semaphore s=new Semaphore(2);
        for (int i = 0; i <3 ; i++) {
            new Thread(()->{
                try{
                    s.acquire();
                    System.out.println("T1 running...");
                    Thread.sleep(200);
                    System.out.println("T1 running...");
                } catch (Exception e){
                    e.printStackTrace();
                }finally {
                    s.release();
                }
            }).start();
        }
    }
}

 

读写锁:

如果是普通锁的话所有读操作完成后才能进行写操作,因为读的是后不允许写操作。

如果是读写锁的话同一时刻所有读线程同时读取数据,读完后再执行写操作。

public class TestReadWriteLock {

    static Lock lock=new ReentrantLock();

    private static int value;

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

    public static void read(Lock lock){
        try{
            lock.lock();
            Thread.sleep(1000);
            System.out.println("read over"+ "====="+value);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public static  void  write(Lock lock,int v){

        try{
            lock.lock();
            Thread.sleep(1000);
            value=v;
            System.out.println("write over"+ "====="+value);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        //传的是reetranLock锁
//        for (int i = 0; i <18 ; i++) {
//            new Thread(()->{
//               read(lock);
//            }).start();
//        }
//        for (int i = 0; i <2 ; i++) {
//            new Thread(()->{
//                write(lock,new Random().nextInt());
//            }).start();
//        }
        //传的是读写锁
        for (int i = 0; i <18 ; i++) {
            new Thread(()->{
                read(readLock);
            }).start();
        }
        for (int i = 0; i <2 ; i++) {
            new Thread(()->{
                write(writeLock,new Random().nextInt());
            }).start();
        }
    }
}

 

posted @ 2021-06-17 17:15  Fly博客  阅读(85)  评论(0)    收藏  举报