Java NIO Pipe

• Creating a Pipe
• Writing to a Pipe
• Reading from a Pipe

A Java NIO Pipe is a one-way data connection between two threads. （线程间的数据交换-connection）

A Pipe has a source channel and a sink（下沉、水槽） channel. You write data to the sink channel. This data can then be read from the source channel.

Here is an illustration of the Pipe principle:

pipe-internals.png

​ Java NIO: Pipe Internals

Creating a Pipe

You open a Pipe by calling the Pipe.open() method. Here is how that looks:

Pipe pipe = Pipe.open();

Writing to a Pipe

To write to a Pipe you need to access the sink channel. Here is how that is done:

Pipe.SinkChannel sinkChannel = pipe.sink();

You write to a SinkChannel by calling it's write() method, like this:

String newData = "New String to write to file..." + System.currentTimeMillis();

ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());

buf.flip();

while(buf.hasRemaining()) {
    sinkChannel.write(buf);
}

Reading from a Pipe

To read from a Pipe you need to access the source channel. Here is how that is done:

Pipe.SourceChannel sourceChannel = pipe.source();

To read from the source channel you call its read() method like this:

ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf);

The int returned by the read() method tells how many bytes were read into the buffer.

  public static void main(String[] args) throws IOException {

        final Pipe pipe = Pipe.open();

        new Thread(new Runnable() {
            public void run() {
                // sinkChannel 用于写入
                Pipe.SinkChannel inChannel = pipe.sink();

                ByteBuffer byteBuffer = ByteBuffer.allocate(48);
                byteBuffer.put("Test Pipe".getBytes());

                byteBuffer.flip();

                int i = 0;
                try {
                    i = inChannel.write(byteBuffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                byteBuffer.clear();
                System.out.println("Thread: " + Thread.currentThread().getName() + ",Write to SinkChannel size:" + i);
            }
        }).start();


        // sourceChannel用于读取
        new Thread(new Runnable() {
            public void run() {
                Pipe.SourceChannel outChannel = pipe.source();
                ByteBuffer readBuf = ByteBuffer.allocate(48);
                try {
                    outChannel.read(readBuf);
                } catch (IOException e) {
                    e.printStackTrace();
                }

                readBuf.flip();
                System.out.print("Thread: " + Thread.currentThread().getName() + ",Read From SourceChannel:");
                while (readBuf.hasRemaining()) {
                    System.out.print((char) readBuf.get());
                }
            }
        }).start();

    }

如果是两个线程，就只能把pipe作为共享变量了。

注意是两个线程，而不是两个进程。