public Semaphore(int permits);//permits就是允許同時運行的線程數(shù)目

public Semaphore(int permits,boolean fair);//permits就是允許同時運行的線程數(shù)目

acquire()  
獲取一個令牌，在獲取到令牌、或者被其他線程調用中斷之前線程一直處于阻塞狀態(tài)。
?
acquire(int permits)  
獲取一個令牌，在獲取到令牌、或者被其他線程調用中斷、或超時之前線程一直處于阻塞狀態(tài)。
acquireUninterruptibly() 
獲取一個令牌，在獲取到令牌之前線程一直處于阻塞狀態(tài)（忽略中斷）。
tryAcquire()
嘗試獲得令牌，返回獲取令牌成功或失敗，不阻塞線程。
?
tryAcquire(long timeout, TimeUnit unit)
嘗試獲得令牌，在超時時間內循環(huán)嘗試獲取，直到嘗試獲取成功或超時返回，不阻塞線程。
?
release()
釋放一個令牌，喚醒一個獲取令牌不成功的阻塞線程。
?
hasQueuedThreads()
等待隊列里是否還存在等待線程。
?
getQueueLength()
獲取等待隊列里阻塞的線程數(shù)。
?
drainPermits()
清空令牌把可用令牌數(shù)置為0，返回清空令牌的數(shù)量。
?
availablePermits()
返回可用的令牌數(shù)量。

public class TestCar {
?
    //停車場同時容納的車輛10
    private  static  Semaphore semaphore=new Semaphore(10);
?
    public static void main(String[] args) {
?
        //模擬100輛車進入停車場
        for(int i=0;i<100;i++){
?
            Thread thread=new Thread(new Runnable() {
                public void run() {
                    try {
                        System.out.println("===="+Thread.currentThread().getName()+"來到停車場");
                        if(semaphore.availablePermits()==0){
                            System.out.println("車位不足，請耐心等待");
                        }
                        semaphore.acquire();//獲取令牌嘗試進入停車場
                        System.out.println(Thread.currentThread().getName()+"成功進入停車場");
                        Thread.sleep(new Random().nextInt(10000));//模擬車輛在停車場停留的時間
                        System.out.println(Thread.currentThread().getName()+"駛出停車場");
                        semaphore.release();//釋放令牌，騰出停車場車位
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },i+"號車");
?
            thread.start();
?
        }
?
    }
}
?

Semaphore semaphore=new Semaphore(2);

semaphore.acquire();

/**
     *  獲取1個令牌
     */
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

/**
     * 共享模式下獲取令牌，獲取成功則返回，失敗則加入阻塞隊列，掛起線程
     * @param arg
     * @throws InterruptedException
     */
    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        //嘗試獲取令牌，arg為獲取令牌個數(shù)，當可用令牌數(shù)減當前令牌數(shù)結果小于0,則創(chuàng)建一個節(jié)點加入阻塞隊列，掛起當前線程。
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

/**
     * 1、創(chuàng)建節(jié)點，加入阻塞隊列，
     * 2、重雙向鏈表的head，tail節(jié)點關系，清空無效節(jié)點
     * 3、掛起當前節(jié)點線程
     * @param arg
     * @throws InterruptedException
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        //創(chuàng)建節(jié)點加入阻塞隊列
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                //獲得當前節(jié)點pre節(jié)點
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);//返回鎖的state
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //重組雙向鏈表，清空無效節(jié)點，掛起當前線程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 semaphore.release();

 /**
     * 釋放令牌
     */
    public void release() {
        sync.releaseShared(1);
    }

/**
     *釋放共享鎖，同時喚醒所有阻塞隊列共享節(jié)點線程
     * @param arg
     * @return
     */
    public final boolean releaseShared(int arg) {
        //釋放共享鎖
        if (tryReleaseShared(arg)) {
            //喚醒所有共享節(jié)點線程
            doReleaseShared();
            return true;
        }
        return false;
    }

 /**
     * 喚醒所有共享節(jié)點線程
     */
    private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {//是否需要喚醒后繼節(jié)點
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//修改狀態(tài)為初始0
                        continue;
                    unparkSuccessor(h);//喚醒h.nex節(jié)點線程
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE));
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }