public static void main(String[] argv) throws Exception {
Pipe[] pipes = new Pipe[PIPES_COUNT];
Pipe pipe = Pipe.open();
Pipe.SinkChannel sink = pipe.sink();
Pipe.SourceChannel source = pipe.source();
Selector sel = Selector.open();
source.configureBlocking(false);
source.register(sel, SelectionKey.OP_READ);
for (int i = 0; i < PIPES_COUNT; i++) {
pipes[i] = Pipe.open();
Pipe.SourceChannel sc = pipes[i].source();
sc.configureBlocking(false);
sc.register(sel, SelectionKey.OP_READ);
Pipe.SinkChannel sc2 = pipes[i].sink();
sc2.configureBlocking(false);
sc2.register(sel, SelectionKey.OP_WRITE);
}
for (int i = 0; i < LOOPS; i++) {
sink.write(ByteBuffer.allocate(BUF_SIZE));
int x = sel.selectNow();
sel.selectedKeys().clear();
source.read(ByteBuffer.allocate(BUF_SIZE));
}
for (int i = 0; i < PIPES_COUNT; i++) {
pipes[i].sink().close();
pipes[i].source().close();
}
pipe.sink().close();
pipe.source().close();
sel.close();
}
private static void scScatter() throws Exception {
Pipe p = Pipe.open();
Pipe.SinkChannel sink = p.sink();
Pipe.SourceChannel source = p.source();
sink.configureBlocking(false);
ByteBuffer outgoingdata = ByteBuffer.allocateDirect(30);
byte[] someBytes = new byte[30];
generator.nextBytes(someBytes);
outgoingdata.put(someBytes);
outgoingdata.flip();
int totalWritten = 0;
while (totalWritten < 30) {
int written = sink.write(outgoingdata);
if (written < 0) throw new Exception("Write failed");
totalWritten += written;
}
ByteBuffer[] bufs = new ByteBuffer[3];
for (int i = 0; i < 3; i++) bufs[i] = ByteBuffer.allocateDirect(10);
long numBytesRead = source.read(bufs);
if (numBytesRead < 30) throw new Exception("Pipe test failed");
sink.close();
source.close();
}
/**
* A convenience method for the following code:
*
* <pre>
* {@link Pipe} inputToOutput = {@link Pipe#open()};
* {@link Pipe.SinkChannel} sink = {@link Pipe#sink() inputToOutput.sink()};
* {@link SelectableChannel#configureBlocking(boolean) sink.configureBlocking(false)};
* {@link #addRoute(SelectableChannel, SelectableChannel) addRoute(input, sink)};
*
* {@link Pipe.SourceChannel} source = {@link Pipe#source() inputToOutput.source()};
* return {@link #wrapChannelInObjectInputStream(ReadableByteChannel) wrapChannelInObjectInputStream(source)};
* </pre>
*
* @throws IOException pass-through for any {@link IOException} that occurs in the above code
*/
public <T extends SelectableChannel & ReadableByteChannel>
ObjectInputStream addRouteToObjectInputStream(T input) throws IOException {
Pipe inputToOutput = Pipe.open();
Pipe.SinkChannel sink = inputToOutput.sink();
sink.configureBlocking(false);
addRoute(input, sink);
Pipe.SourceChannel source = inputToOutput.source();
return wrapChannelInObjectInputStream(source);
}
/*
* @see java.nio.channels.Selector#wakeup()
*/
public Selector wakeup() {
try {
sink.write(ByteBuffer.allocate(MOCK_WRITEBUF_SIZE));
} catch (IOException e) {
// do nothing
}
return this;
}
public void send() {
int nbytes = 0;
ByteBuffer dummy = ByteBuffer.allocate(1);
while (true) {
try {
Thread.interrupted();
nbytes = w.write(dummy);
} catch (IOException e) {
throw new ZError.IOException(e);
}
if (nbytes == 0) {
continue;
}
assert (nbytes == 1);
wcursor.incrementAndGet();
break;
}
}
@Override
public void close() throws IOException {
IOException exception = null;
try {
r.close();
} catch (IOException e) {
exception = e;
}
try {
w.close();
} catch (IOException e) {
exception = e;
}
try {
selector.close();
} catch (IOException e) {
exception = e;
}
if (exception != null) {
throw exception;
}
}
public SelectionKey keyFor(final Selector sel) {
return wrapped.keyFor(sel);
}
public int write(final ByteBuffer src) throws IOException {
return wrapped.write(src);
}
public long write(final ByteBuffer[] srcs, final int offset, final int length)
throws IOException {
return wrapped.write(srcs, offset, length);
}
public SelectableChannel configureBlocking(final boolean block) throws IOException {
return wrapped.configureBlocking(block);
}
protected void implCloseChannel() throws IOException {
wrapped.close();
}
public SelectorProvider provider() {
return wrapped.provider();
}
public int validOps() {
return wrapped.validOps();
}
public boolean isRegistered() {
return wrapped.isRegistered();
}
public long write(final ByteBuffer[] srcs) throws IOException {
return wrapped.write(srcs);
}
public SelectionKey register(final Selector sel, final int ops, final Object att)
throws ClosedChannelException {
return wrapped.register(sel, ops, att);
}
public boolean isBlocking() {
return wrapped.isBlocking();
}
public Object blockingLock() {
return wrapped.blockingLock();
}
