public boolean awaitUninterruptibly(long timeout, TimeUnit unit) { try { return await0(unit.toNanos(timeout), false); } catch (InterruptedException e) { throw new InternalError(); } }
public ChannelGroupFuture await() throws InterruptedException { if (Thread.interrupted()) { throw new InterruptedException(); } synchronized (this) { while (!done) { checkDeadLock(); waiters++; try { wait(); } finally { waiters--; } } } return this; }
private void notifyListeners() { // This method doesn't need synchronization because: // 1) This method is always called after synchronized (this) block. // Hence any listener list modification happens-before this method. // 2) This method is called only when 'done' is true. Once 'done' // becomes true, the listener list is never modified - see add/removeListener() if (firstListener != null) { notifyListener(firstListener); firstListener = null; if (otherListeners != null) { for (ChannelGroupFutureListener l: otherListeners) { notifyListener(l); } otherListeners = null; } } }
public ChannelGroupFuture write(Object message) { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); if (message instanceof ChannelBuffer) { ChannelBuffer buf = (ChannelBuffer) message; for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.write(buf.duplicate())); } } else { for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.write(message)); } } return new DefaultChannelGroupFuture(this, futures); }
DefaultChannelGroupFuture(ChannelGroup group, Map<Integer, ChannelFuture> futures) { this.group = group; this.futures = Collections.unmodifiableMap(futures); for (ChannelFuture f: this.futures.values()) { f.addListener(childListener); } // Done on arrival? if (this.futures.isEmpty()) { setDone(); } }
boolean setDone() { synchronized (this) { // Allow only once. if (done) { return false; } done = true; if (waiters > 0) { notifyAll(); } } notifyListeners(); return true; }
public ChannelGroupFuture write(Object message, SocketAddress remoteAddress) { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); if (message instanceof ChannelBuffer) { ChannelBuffer buf = (ChannelBuffer) message; for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.write(buf.duplicate(), remoteAddress)); } } else { for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.write(message, remoteAddress)); } } return new DefaultChannelGroupFuture(this, futures); }
public void operationComplete(ChannelFuture future) throws Exception { boolean success = future.isSuccess(); boolean callSetDone; synchronized (DefaultChannelGroupFuture.this) { if (success) { successCount ++; } else { failureCount ++; } callSetDone = successCount + failureCount == futures.size(); assert successCount + failureCount <= futures.size(); } if (callSetDone) { setDone(); } } };
public ChannelGroupFuture close() { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); for (Channel c: serverChannels.values()) { futures.put(c.getId(), c.close().awaitUninterruptibly()); } for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.close()); } return new DefaultChannelGroupFuture(this, futures); }
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return await0(unit.toNanos(timeout), true); }
/** * Creates a new instance. */ public DefaultChannelGroupFuture(ChannelGroup group, Collection<ChannelFuture> futures) { if (group == null) { throw new NullPointerException("group"); } if (futures == null) { throw new NullPointerException("futures"); } this.group = group; Map<Integer, ChannelFuture> futureMap = new LinkedHashMap<Integer, ChannelFuture>(); for (ChannelFuture f: futures) { futureMap.put(f.getChannel().getId(), f); } this.futures = Collections.unmodifiableMap(futureMap); for (ChannelFuture f: this.futures.values()) { f.addListener(childListener); } // Done on arrival? if (this.futures.isEmpty()) { setDone(); } }
public ChannelGroupFuture awaitUninterruptibly() { boolean interrupted = false; synchronized (this) { while (!done) { checkDeadLock(); waiters++; try { wait(); } catch (InterruptedException e) { interrupted = true; } finally { waiters--; } } } if (interrupted) { Thread.currentThread().interrupt(); } return this; }
public void addListener(ChannelGroupFutureListener listener) { if (listener == null) { throw new NullPointerException("listener"); } boolean notifyNow = false; synchronized (this) { if (done) { notifyNow = true; } else { if (firstListener == null) { firstListener = listener; } else { if (otherListeners == null) { otherListeners = new ArrayList<ChannelGroupFutureListener>(1); } otherListeners.add(listener); } } } if (notifyNow) { notifyListener(listener); } }
public ChannelGroupFuture setInterestOps(int interestOps) { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); for (Channel c: serverChannels.values()) { futures.put(c.getId(), c.setInterestOps(interestOps).awaitUninterruptibly()); } for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.setInterestOps(interestOps)); } return new DefaultChannelGroupFuture(this, futures); }
public boolean await(long timeoutMillis) throws InterruptedException { return await0(MILLISECONDS.toNanos(timeoutMillis), true); }
checkDeadLock(); waiters++; try {
public ChannelGroupFuture unbind() { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); for (Channel c: serverChannels.values()) { futures.put(c.getId(), c.unbind().awaitUninterruptibly()); } for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.unbind()); } return new DefaultChannelGroupFuture(this, futures); }
public boolean awaitUninterruptibly(long timeoutMillis) { try { return await0(MILLISECONDS.toNanos(timeoutMillis), false); } catch (InterruptedException e) { throw new InternalError(); } }
public ChannelGroupFuture disconnect() { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); for (Channel c: serverChannels.values()) { futures.put(c.getId(), c.disconnect().awaitUninterruptibly()); } for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.disconnect()); } return new DefaultChannelGroupFuture(this, futures); }
public ChannelGroupFuture setReadable(boolean readable) { Map<Integer, ChannelFuture> futures = new LinkedHashMap<Integer, ChannelFuture>(size()); for (Channel c: serverChannels.values()) { futures.put(c.getId(), c.setReadable(readable).awaitUninterruptibly()); } for (Channel c: nonServerChannels.values()) { futures.put(c.getId(), c.setReadable(readable)); } return new DefaultChannelGroupFuture(this, futures); }