管道Pipe

/* * @(#)Pipe.java    1.21 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package java.nio.channels;import java.io.IOException;import java.nio.channels.spi.*;/** * A pair of channels that implements a unidirectional pipe. * * <p> A pipe consists of a pair of channels: A writable {@link * Pipe.SinkChannel </code>sink<code>} channel and a readable {@link * Pipe.SourceChannel </code>source<code>} channel.  Once some bytes are * written to the sink channel they can be read from source channel in exactly * the order in which they were written. * * <p> Whether or not a thread writing bytes to a pipe will block until another * thread reads those bytes, or some previously-written bytes, from the pipe is * system-dependent and therefore unspecified.  Many pipe implementations will * buffer up to a certain number of bytes between the sink and source channels, * but such buffering should not be assumed.  </p> * * * @author Mark Reinhold * @author JSR-51 Expert Group * @version 1.21, 05/11/17 * @since 1.4 */public abstract class Pipe {    /**     * A channel representing the readable end of a {@link Pipe}.  </p>     *     * @since 1.4     */    public static abstract class SourceChannel    extends AbstractSelectableChannel    implements ReadableByteChannel, ScatteringByteChannel    {    /**     * Constructs a new instance of this class.     */    protected SourceChannel(SelectorProvider provider) {        super(provider);    }    /**     * Returns an operation set identifying this channel‘s supported     * operations.     *     * <p> Pipe-source channels only support reading, so this method     * returns {@link SelectionKey#OP_READ}.  </p>     *     * @return  The valid-operation set     */    public final int validOps() {        return SelectionKey.OP_READ;    }    }    /**     * A channel representing the writable end of a {@link Pipe}.  </p>     *     * @since 1.4     */    public static abstract class SinkChannel    extends AbstractSelectableChannel    implements WritableByteChannel, GatheringByteChannel    {    /**     * Initializes a new instance of this class.     */    protected SinkChannel(SelectorProvider provider) {        super(provider);    }    /**     * Returns an operation set identifying this channel‘s supported     * operations.     *     * <p> Pipe-sink channels only support writing, so this method returns     * {@link SelectionKey#OP_WRITE}.  </p>     *     * @return  The valid-operation set     */    public final int validOps() {        return SelectionKey.OP_WRITE;    }    }    /**     * Initializes a new instance of this class.     */    protected Pipe() { }    /**     * Returns this pipe‘s source channel.  </p>     *     * @return  This pipe‘s source channel     */    public abstract SourceChannel source();    /**     * Returns this pipe‘s sink channel.  </p>     *     * @return  This pipe‘s sink channel     */    public abstract SinkChannel sink();    /**     * Opens a pipe.     *     * <p> The new pipe is created by invoking the {@link     * java.nio.channels.spi.SelectorProvider#openPipe openPipe} method of the     * system-wide default {@link java.nio.channels.spi.SelectorProvider}     * object.  </p>     *     * @return  A new pipe     *     * @throws  IOException     *          If an I/O error occurs     */    public static Pipe open() throws IOException {    return SelectorProvider.provider().openPipe();    }}

/** *  */package test.nio.pipe;import java.nio.ByteBuffer;import java.nio.channels.Channels;import java.nio.channels.Pipe;import java.nio.channels.ReadableByteChannel;import java.nio.channels.WritableByteChannel;import java.util.Random;/** * * Test Pipe objects using a worker thread. ** Created April, 2002 * @author * Ron Hitchens (ron@ronsoft.com) */public class PipeTest {    public static void main(String[] argv) throws Exception {        // Wrap a channel around stdout        WritableByteChannel out = Channels.newChannel(System.out);        // Start worker and get read end of channel        ReadableByteChannel workerChannel = startWorker(10);        ByteBuffer buffer = ByteBuffer.allocate(100);        while (workerChannel.read(buffer) >= 0) {            buffer.flip();            out.write(buffer);            buffer.clear();        }    }    // This method could return a SocketChannel or    // FileChannel instance just as easily    private static ReadableByteChannel startWorker(int reps) throws Exception {        Pipe pipe = Pipe.open();        Worker worker = new Worker(pipe.sink(), reps);        worker.start();        return (pipe.source());    }// -----------------------------------------------------------------    /**     * * A worker thread object which writes data down a channel. * Note: this     * object knows nothing about Pipe, uses only a * generic     * WritableByteChannel.     */    private static class Worker extends Thread {        WritableByteChannel channel;        private int reps;        Worker(WritableByteChannel channel, int reps) {            this.channel = channel;            this.reps = reps;        }        // Thread execution begins here        public void run() {            ByteBuffer buffer = ByteBuffer.allocate(100);            try {                for (int i = 0; i < this.reps; i++) {                    doSomeWork(buffer);                    // channel may not take it all at once                    while (channel.write(buffer) > 0) {                        // empty                    }                }                this.channel.close();            } catch (Exception e) {                // easy way out; this is demo code                e.printStackTrace();            }        }        private String[] products = { "No good deed goes unpunished",                "To be, or what?", "No matter where you go, there you are",                "Just say \"Yo\"", "My karma ran over my dogma" };        private Random rand = new Random();        private void doSomeWork(ByteBuffer buffer) {            int product = rand.nextInt(products.length);            buffer.clear();            buffer.put(products[product].getBytes());            buffer.put("\r\n".getBytes());            buffer.flip();        }    }}