Semaphore

 

 

package com.study.concurrent_utils;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class JamesSemaphore {

    private Sync sync;

    public JamesSemaphore(int permits){
        sync = new Sync(permits);
    }

    public void acquire(){
        sync.acquireShared(1);
    }

    public void release(){
        sync.releaseShared(1);
    }



    class Sync extends AbstractQueuedSynchronizer{
        private int permits;

        public Sync(int permits){
            this.permits = permits;
        }

        @Override
        protected int tryAcquireShared(int arg) {
            int state = getState();
            int nextState = state + arg;

            //如果信号量没占满，加锁的个数没有达到permits
            if (nextState <= permits){
                if (compareAndSetState(state, nextState))
                    return 1;
            }
            return -1;
        }


        @Override
        protected boolean tryReleaseShared(int arg) {
            int state = getState();
            if (compareAndSetState(state, state - arg)){
                return true;
            }else{
                return false;
            }
        }
    }
}

package com.study.concurrent_utils;

import java.util.concurrent.Semaphore;

public class Tset_Semaphore {
    static JamesSemaphore sp = new JamesSemaphore(6);

    public static void main(String args[]){
        for (int i=0; i<1000; i++){
            new Thread(){
                @Override
                public void run() {
                    try {
                        sp.acquire();       //抢信号量、就是在加锁
                        Thread.sleep(2000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    queryDB("localhost:3006");
                    sp.release();       //释放信号量，就是解锁
                }
            }.start();
        }
    }

    public static void queryDB(String url){
        System.out.println("query " + url);
    }
}