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();
}
/*
* CancelledKeyException is the failure symptom of 4729342
* NOTE: The failure is timing dependent and is not always
* seen immediately when the bug is present.
*/
public static void main(String[] args) throws Exception {
InetAddress lh = InetAddress.getLocalHost();
isa = new InetSocketAddress(lh, TEST_PORT);
selector = Selector.open();
ssc = ServerSocketChannel.open();
// Create and start a selector in a separate thread.
new Thread(
new Runnable() {
public void run() {
try {
ssc.configureBlocking(false);
ssc.socket().bind(isa);
sk = ssc.register(selector, SelectionKey.OP_ACCEPT);
selector.select();
} catch (IOException e) {
System.err.println("error in selecting thread");
e.printStackTrace();
}
}
})
.start();
// Wait for above thread to get to select() before we call close.
Thread.sleep(3000);
// Try to close. This should wakeup select.
new Thread(
new Runnable() {
public void run() {
try {
SocketChannel sc = SocketChannel.open();
sc.connect(isa);
ssc.close();
sk.cancel();
sc.close();
} catch (IOException e) {
System.err.println("error in closing thread");
System.err.println(e);
}
}
})
.start();
// Wait for select() to be awakened, which should be done by close.
Thread.sleep(3000);
selector.wakeup();
selector.close();
}
public void run() {
for (; ; ) {
try {
int n = sel.select();
if (n > 0) processSelectedKeys();
processPendingTargets();
if (shutdown) {
sel.close();
return;
}
} catch (IOException x) {
x.printStackTrace();
}
}
}
void close() {
try {
if (mySelector != null) mySelector.close();
} catch (IOException e) {
}
mySelector = null;
// run down open connections and sockets.
Iterator<ServerSocketChannel> i = Acceptors.values().iterator();
while (i.hasNext()) {
try {
i.next().close();
} catch (IOException e) {
}
}
// 29Sep09: We create an ArrayList of the existing connections, then iterate over
// that to call unbind on them. This is because an unbind can trigger a reconnect,
// which will add to the Connections HashMap, causing a ConcurrentModificationException.
// XXX: The correct behavior here would be to latch the various reactor methods to return
// immediately if the reactor is shutting down.
ArrayList<EventableChannel> conns = new ArrayList<EventableChannel>();
Iterator<EventableChannel> i2 = Connections.values().iterator();
while (i2.hasNext()) {
EventableChannel ec = i2.next();
if (ec != null) {
conns.add(ec);
}
}
Connections.clear();
ListIterator<EventableChannel> i3 = conns.listIterator(0);
while (i3.hasNext()) {
EventableChannel ec = i3.next();
eventCallback(ec.getBinding(), EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
ListIterator<EventableSocketChannel> i4 = DetachedConnections.listIterator(0);
while (i4.hasNext()) {
EventableSocketChannel ec = i4.next();
ec.cleanup();
}
DetachedConnections.clear();
}
void closeIO() {
logger.log(Level.FINEST, "Closing server channel, etc.");
if (serverChannel != null) {
try {
serverChannel.close();
} catch (java.io.IOException ex) {
}
}
serverChannel = null;
try {
selector.close();
} catch (java.io.IOException ex) {
}
selector = null;
logger.log(Level.FINEST, "Closed selector, etc.");
}
/** Close. */
public void close() {
if (selector != null) {
selector.wakeup();
try {
selector.close();
} catch (IOException e1) {
log.warn("close selector fails", e1);
} finally {
selector = null;
}
}
if (server != null) {
try {
server.socket().close();
server.close();
} catch (IOException e) {
log.warn("close socket server fails", e);
} finally {
server = null;
}
}
}