jdk-sandbox: comparison src/java.base/share/classes/sun/nio/ch/ServerSocketChannelImpl.java

equal deleted inserted replaced

-:a8535f04b465
+:193a8f1a4f3b
 import java.nio.channels.spi.SelectorProvider;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
-import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 import sun.net.NetHooks;
 import sun.net.ext.ExtendedSocketOptions;
 // Lock held by thread currently blocked on this channel
 private final ReentrantLock acceptLock = new ReentrantLock();
 // Lock held by any thread that modifies the state fields declared below
 // DO NOT invoke a blocking I/O operation while holding this lock!
-private final ReentrantLock stateLock = new ReentrantLock();
+private final Object stateLock = new Object();
-private final Condition stateCondition = stateLock.newCondition();
 // -- The following fields are protected by stateLock
 // Channel state, increases monotonically
 private static final int ST_INUSE = 0;
 private static final int ST_CLOSING = 1;
-private static final int ST_KILLPENDING = 2;
+private static final int ST_CLOSED = 2;
-private static final int ST_KILLED = 3;
 private int state;
 // ID of native thread currently blocked in this channel, for signalling
 private long thread;
 {
 super(sp);
 this.fd =  fd;
 this.fdVal = IOUtil.fdVal(fd);
 if (bound) {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 localAddress = Net.localAddress(fd);
-} finally {
-stateLock.unlock();
 }
 }
 }
 // @throws ClosedChannelException if channel is closed
 throw new ClosedChannelException();
 }
 @Override
 public ServerSocket socket() {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 if (socket == null)
 socket = ServerSocketAdaptor.create(this);
 return socket;
-} finally {
-stateLock.unlock();
 }
 }
 @Override
 public SocketAddress getLocalAddress() throws IOException {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 return (localAddress == null)
 ? null
 : Net.getRevealedLocalAddress(localAddress);
-} finally {
-stateLock.unlock();
 }
 }
 @Override
 public <T> ServerSocketChannel setOption(SocketOption<T> name, T value)
 throws IOException
 {
 Objects.requireNonNull(name);
 if (!supportedOptions().contains(name))
 throw new UnsupportedOperationException("'" + name + "' not supported");
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 if (name == StandardSocketOptions.SO_REUSEADDR && Net.useExclusiveBind()) {
 // SO_REUSEADDR emulated when using exclusive bind
 isReuseAddress = (Boolean)value;
 } else {
 // no options that require special handling
 Net.setSocketOption(fd, Net.UNSPEC, name, value);
 }
 return this;
-} finally {
-stateLock.unlock();
 }
 }
 @Override
 @SuppressWarnings("unchecked")
 {
 Objects.requireNonNull(name);
 if (!supportedOptions().contains(name))
 throw new UnsupportedOperationException("'" + name + "' not supported");
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 if (name == StandardSocketOptions.SO_REUSEADDR && Net.useExclusiveBind()) {
 // SO_REUSEADDR emulated when using exclusive bind
 return (T)Boolean.valueOf(isReuseAddress);
 }
 // no options that require special handling
 return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
-} finally {
-stateLock.unlock();
 }
 }
 private static class DefaultOptionsHolder {
 static final Set<SocketOption<?>> defaultOptions = defaultOptions();
 return DefaultOptionsHolder.defaultOptions;
 }
 @Override
 public ServerSocketChannel bind(SocketAddress local, int backlog) throws IOException {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 if (localAddress != null)
 throw new AlreadyBoundException();
 InetSocketAddress isa = (local == null)
 ? new InetSocketAddress(0)
 sm.checkListen(isa.getPort());
 NetHooks.beforeTcpBind(fd, isa.getAddress(), isa.getPort());
 Net.bind(fd, isa.getAddress(), isa.getPort());
 Net.listen(fd, backlog < 1 ? 50 : backlog);
 localAddress = Net.localAddress(fd);
-} finally {
-stateLock.unlock();
 }
 return this;
 }
 /**
 * @throws NotYetBoundException if the channel's socket has not been bound yet
 */
 private void begin(boolean blocking) throws ClosedChannelException {
 if (blocking)
 begin();  // set blocker to close channel if interrupted
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 if (localAddress == null)
 throw new NotYetBoundException();
 if (blocking)
 thread = NativeThread.current();
-} finally {
-stateLock.unlock();
 }
 }
 /**
 * Marks the end of an I/O operation that may have blocked.
 */
 private void end(boolean blocking, boolean completed)
 throws AsynchronousCloseException
 {
 if (blocking) {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 thread = 0;
-// notify any thread waiting in implCloseSelectableChannel
 if (state == ST_CLOSING) {
-stateCondition.signalAll();
+tryFinishClose();
 }
-} finally {
-stateLock.unlock();
 }
 end(completed);
 }
 }
 /**
 * Adjust the blocking mode while holding acceptLock.
 */
 private void lockedConfigureBlocking(boolean block) throws IOException {
 assert acceptLock.isHeldByCurrentThread();
-stateLock.lock();
+synchronized (stateLock) {
-try {
 ensureOpen();
 IOUtil.configureBlocking(fd, block);
-} finally {
+}
-stateLock.unlock();
+}
-}
-}
+/**
+* Closes the socket if there are no accept in progress and the channel is
-/**
+* not registered with a Selector.
-* Invoked by implCloseChannel to close the channel.
+*/
-*
+private boolean tryClose() throws IOException {
-* This method waits for outstanding I/O operations to complete. When in
+assert Thread.holdsLock(stateLock) && state == ST_CLOSING;
-* blocking mode, the socket is pre-closed and the threads in blocking I/O
+if ((thread == 0) && !isRegistered()) {
-* operations are signalled to ensure that the outstanding I/O operations
+state = ST_CLOSED;
-* complete quickly.
+nd.close(fd);
-*
+return true;
-* The socket is closed by this method when it is not registered with a
+} else {
-* Selector. Note that a channel configured blocking may be registered with
+return false;
-* a Selector. This arises when a key is canceled and the channel configured
+}
-* to blocking mode before the key is flushed from the Selector.
+}
-*/
-@Override
+/**
-protected void implCloseSelectableChannel() throws IOException {
+* Invokes tryClose to attempt to close the socket.
-assert !isOpen();
+*
+* This method is used for deferred closing by I/O and Selector operations.
-boolean interrupted = false;
+*/
-boolean blocking;
+private void tryFinishClose() {
-// set state to ST_CLOSING
-stateLock.lock();
 try {
+tryClose();
+} catch (IOException ignore) { }
+}
+/**
+* Closes this channel when configured in blocking mode.
+*
+* If there is an accept in progress then the socket is pre-closed and the
+* accept thread is signalled, in which case the final close is deferred
+* until the accept aborts.
+*/
+private void implCloseBlockingMode() throws IOException {
+synchronized (stateLock) {
 assert state < ST_CLOSING;
 state = ST_CLOSING;
-blocking = isBlocking();
+if (!tryClose()) {
-} finally {
-stateLock.unlock();
-}
-// wait for any outstanding accept to complete
-if (blocking) {
-stateLock.lock();
-try {
-assert state == ST_CLOSING;
 long th = thread;
 if (th != 0) {
 nd.preClose(fd);
 NativeThread.signal(th);
-// wait for accept operation to end
-while (thread != 0) {
-try {
-stateCondition.await();
-} catch (InterruptedException e) {
-interrupted = true;
-}
-}
 }
-} finally {
+}
-stateLock.unlock();
+}
 }
+/**
+* Closes this channel when configured in non-blocking mode.
+*
+* If the channel is registered with a Selector then the close is deferred
+* until the channel is flushed from all Selectors.
+*/
+private void implCloseNonBlockingMode() throws IOException {
+synchronized (stateLock) {
+assert state < ST_CLOSING;
+state = ST_CLOSING;
+}
+// wait for any accept to complete before trying to close
+acceptLock.lock();
+acceptLock.unlock();
+synchronized (stateLock) {
+if (state == ST_CLOSING) {
+tryClose();
+}
+}
+}
+/**
+* Invoked by implCloseChannel to close the channel.
+*/
+@Override
+protected void implCloseSelectableChannel() throws IOException {
+assert !isOpen();
+if (isBlocking()) {
+implCloseBlockingMode();
 } else {
-// non-blocking mode: wait for accept to complete
+implCloseNonBlockingMode();
-acceptLock.lock();
+}
-acceptLock.unlock();
+}
-}
+@Override
-// set state to ST_KILLPENDING
+public void kill() {
-stateLock.lock();
+synchronized (stateLock) {
-try {
+if (state == ST_CLOSING) {
-assert state == ST_CLOSING;
+tryFinishClose();
-state = ST_KILLPENDING;
+}
-} finally {
-stateLock.unlock();
-}
-// close socket if not registered with Selector
-if (!isRegistered())
-kill();
-// restore interrupt status
-if (interrupted)
-Thread.currentThread().interrupt();
-}
-@Override
-public void kill() throws IOException {
-stateLock.lock();
-try {
-if (state == ST_KILLPENDING) {
-state = ST_KILLED;
-nd.close(fd);
-}
-} finally {
-stateLock.unlock();
 }
 }
 /**
 * Returns true if channel's socket is bound
 */
 boolean isBound() {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 return localAddress != null;
-} finally {
-stateLock.unlock();
 }
 }
 /**
 * Returns the local address, or null if not bound
 */
 InetSocketAddress localAddress() {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 return localAddress;
-} finally {
-stateLock.unlock();
 }
 }
 /**
 * Translates native poll revent set into a ready operation set
 sb.append(this.getClass().getName());
 sb.append('[');
 if (!isOpen()) {
 sb.append("closed");
 } else {
-stateLock.lock();
+synchronized (stateLock) {
-try {
 InetSocketAddress addr = localAddress;
 if (addr == null) {
 sb.append("unbound");
 } else {
 sb.append(Net.getRevealedLocalAddressAsString(addr));
 }
-} finally {
-stateLock.unlock();
 }
 }
 sb.append(']');
 return sb.toString();
 }

changeset 54754	193a8f1a4f3b
parent 54620	13b67c1420b8
child 55081	dd321e3596c0
child 57358	f0a1d9760c5e