摘要：一般用于控制并發(fā)線程數(shù)，及線程間互斥。單個(gè)信號(hào)量的對(duì)象可以實(shí)現(xiàn)互斥鎖的功能，并且可以是由一個(gè)線程獲得了鎖，再由另一個(gè)線程釋放鎖，這可應(yīng)用于死鎖恢復(fù)的一些場(chǎng)合。

先說(shuō)說(shuō)Semaphore，Semaphore可以控制某個(gè)資源可被同時(shí)訪問(wèn)的個(gè)數(shù)，通過(guò) acquire() 獲取一個(gè)許可，如果沒(méi)有就等待，而 release() 釋放一個(gè)許可。一般用于控制并發(fā)線程數(shù)，及線程間互斥。另外重入鎖 ReentrantLock 也可以實(shí)現(xiàn)該功能，但實(shí)現(xiàn)上要復(fù)雜些。
功能就類似廁所有5個(gè)坑，假如有10個(gè)人要上廁所，那么同時(shí)只能有多少個(gè)人去上廁所呢？同時(shí)只能有5個(gè)人能夠占用，當(dāng)5個(gè)人中 的任何一個(gè)人讓開(kāi)后，其中等待的另外5個(gè)人中又有一個(gè)人可以占用了。另外等待的5個(gè)人中可以是隨機(jī)獲得優(yōu)先機(jī)會(huì)，也可以是按照先來(lái)后到的順序獲得機(jī)會(huì)。
單個(gè)信號(hào)量的Semaphore對(duì)象可以實(shí)現(xiàn)互斥鎖的功能，并且可以是由一個(gè)線程獲得了“鎖”，再由另一個(gè)線程釋放“鎖”，這可應(yīng)用于死鎖恢復(fù)的一些場(chǎng)合。

/**
 * @Description:
 * @param @param args
 * @return void 返回類型
 */
public static void main(String[] args) {
    // 線程池
    ExecutorService exec = Executors.newCachedThreadPool();
    // 只能5個(gè)線程同時(shí)訪問(wèn)
    final Semaphore semp = new Semaphore(5);
    // 模擬20個(gè)客戶端訪問(wèn)
    for (int index = 0; index < 20; index++) {
        final int NO = index;
        Runnable run = new Runnable() {
            public void run() {
                try {
                    // 獲取許可
                    semp.acquire();
                    System.out.println("獲得Accessing: " + NO);
                    Thread.sleep((long) (Math.random() * 10000));
                    // 訪問(wèn)完后，釋放
                    semp.release();
                    System.out.println("剩余可用信號(hào)-----------------"
                            + semp.availablePermits());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        exec.execute(run);
    }
    // 退出線程池
    exec.shutdown();
}

獲得Accessing: 1
獲得Accessing: 5
獲得Accessing: 2
獲得Accessing: 3
獲得Accessing: 0
剩余可用信號(hào)-----------------1
獲得Accessing: 4
剩余可用信號(hào)-----------------1
獲得Accessing: 9
剩余可用信號(hào)-----------------1
獲得Accessing: 8
剩余可用信號(hào)-----------------1
獲得Accessing: 6
剩余可用信號(hào)-----------------1
獲得Accessing: 10
剩余可用信號(hào)-----------------1
獲得Accessing: 11
剩余可用信號(hào)-----------------1
獲得Accessing: 12
剩余可用信號(hào)-----------------1
獲得Accessing: 13
剩余可用信號(hào)-----------------1
獲得Accessing: 7
剩余可用信號(hào)-----------------1
獲得Accessing: 15
剩余可用信號(hào)-----------------1
獲得Accessing: 16
剩余可用信號(hào)-----------------1
獲得Accessing: 17
剩余可用信號(hào)-----------------1
獲得Accessing: 14
剩余可用信號(hào)-----------------1
獲得Accessing: 18
剩余可用信號(hào)-----------------1
獲得Accessing: 19
剩余可用信號(hào)-----------------1
剩余可用信號(hào)-----------------2
剩余可用信號(hào)-----------------3
剩余可用信號(hào)-----------------4
剩余可用信號(hào)-----------------5

Pipe有一個(gè)source通道和一個(gè)sink通道。數(shù)據(jù)會(huì)被寫到sink通道，從source通道讀取。一進(jìn)一出。先作為初步了解怎么使用。
值得注意的是該類在java.nio.channels下，說(shuō)明該類屬于nio方式的數(shù)據(jù)通信方式，那就使用Buffer來(lái)緩沖數(shù)據(jù)。

Pipe原理的圖示：

Pipe就是個(gè)空管子，這個(gè)空管子一頭可以從管子里往外讀，一頭可以往管子里寫

操作流程：

1.首先要有一個(gè)對(duì)象往這個(gè)空管子里面寫。寫到哪里呢？這個(gè)空管子是有一點(diǎn)空間的，就在這個(gè)管子里。

寫的時(shí)候就是寫到管子本身包含的這段空間里的。這段空間大小是1024個(gè)字節(jié)。

2.然后另一個(gè)對(duì)象才能將這個(gè)裝滿了的管子里的內(nèi)容讀出來(lái)。

package com.jx.test;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

public class testPipe {

    /**
     * @Description:
     * @param @param args
     * @return void 返回類型
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 創(chuàng)建一個(gè)管道
        Pipe pipe = Pipe.open();
        final Pipe.SinkChannel psic = pipe.sink();// 要向管道寫數(shù)據(jù)，需要訪問(wèn)sink通道
        final Pipe.SourceChannel psoc = pipe.source();// 從讀取管道的數(shù)據(jù)，需要訪問(wèn)source通道

        Thread tPwriter = new Thread() {

            public void run() {
                try {
                    System.out.println("send.....");
                    // 創(chuàng)建一個(gè)線程，利用管道的寫入口Pipe.SinkChannel類型的psic往管道里寫入指定ByteBuffer的內(nèi)容
                    int res = psic.write(ByteBuffer
                            .wrap("Hello,Pipe!測(cè)試通訊.....".getBytes("utf-16BE")));
                    System.out.println("send size:" + res);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        Thread tPreader = new Thread() {
            public void run() {
                int bbufferSize = 1024 * 2;
                ByteBuffer bbuffer = ByteBuffer.allocate(bbufferSize);
                try {
                    System.out.println("recive.....");
                    // 創(chuàng)建一個(gè)線程，利用管道的讀入口Pipe.SourceChannel類型的psoc將管道里內(nèi)容讀到指定的ByteBuffer中                    
                    int res = psoc.read(bbuffer);//數(shù)據(jù)未
                     System.out.println("recive size:"+res+" Content:" + ByteBufferToString(bbuffer));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        tPwriter.start();
        tPreader.start();
    }

    /**
     *ByteBuffer--> String的轉(zhuǎn)換函數(shù)
     */
    public static String ByteBufferToString(ByteBuffer content) {
        if (content == null || content.limit() <= 0
                || (content.limit() == content.remaining())) {
            System.out.println("不存在或內(nèi)容為空！");
            return null;
        }
        int contentSize = content.limit() - content.remaining();
        StringBuffer resultStr = new StringBuffer();
        for (int i = 0; i < contentSize; i += 2) {
            resultStr.append(content.getChar(i));
        }
        return resultStr.toString();
    }

}