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

equal deleted inserted replaced

-:b43cc3b9ef40
+:13b67c1420b8
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.SocketAddress;
 import java.net.SocketOption;
+import java.net.SocketTimeoutException;
 import java.net.StandardSocketOptions;
 import java.nio.channels.AlreadyBoundException;
 import java.nio.channels.AsynchronousCloseException;
 import java.nio.channels.ClosedChannelException;
+import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.NotYetBoundException;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
 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 Object stateLock = new Object();
+private final ReentrantLock stateLock = new ReentrantLock();
+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 ServerSocket socket;
 // -- End of fields protected by stateLock
-ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
+ServerSocketChannelImpl(SelectorProvider sp) {
 super(sp);
 this.fd = Net.serverSocket(true);
 this.fdVal = IOUtil.fdVal(fd);
 }
 {
 super(sp);
 this.fd =  fd;
 this.fdVal = IOUtil.fdVal(fd);
 if (bound) {
-synchronized (stateLock) {
+stateLock.lock();
+try {
 localAddress = Net.localAddress(fd);
+} finally {
+stateLock.unlock();
 }
 }
 }
 // @throws ClosedChannelException if channel is closed
 throw new ClosedChannelException();
 }
 @Override
 public ServerSocket socket() {
-synchronized (stateLock) {
+stateLock.lock();
+try {
 if (socket == null)
 socket = ServerSocketAdaptor.create(this);
 return socket;
+} finally {
+stateLock.unlock();
 }
 }
 @Override
 public SocketAddress getLocalAddress() throws IOException {
-synchronized (stateLock) {
+stateLock.lock();
+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");
-synchronized (stateLock) {
+stateLock.lock();
+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");
-synchronized (stateLock) {
+stateLock.lock();
+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 {
-synchronized (stateLock) {
+stateLock.lock();
+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
-synchronized (stateLock) {
+stateLock.lock();
+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) {
-synchronized (stateLock) {
+stateLock.lock();
+try {
 thread = 0;
 // notify any thread waiting in implCloseSelectableChannel
 if (state == ST_CLOSING) {
-stateLock.notifyAll();
+stateCondition.signalAll();
 }
+} finally {
+stateLock.unlock();
 }
 end(completed);
 }
 }
 acceptLock.lock();
 try {
 boolean blocking = isBlocking();
 try {
 begin(blocking);
-do {
+n = Net.accept(this.fd, newfd, isaa);
-n = Net.accept(this.fd, newfd, isaa);
+if (blocking) {
-} while (n == IOStatus.INTERRUPTED && isOpen());
+while (IOStatus.okayToRetry(n) && isOpen()) {
+park(Net.POLLIN);
+n = Net.accept(this.fd, newfd, isaa);
+}
+}
 } finally {
 end(blocking, n > 0);
 assert IOStatus.check(n);
 }
 } finally {
 acceptLock.unlock();
 }
-if (n < 1)
+if (n > 0) {
+return finishAccept(newfd, isaa[0]);
+} else {
 return null;
+}
-InetSocketAddress isa = isaa[0];
+}
+/**
+* Accepts a new connection with a given timeout. This method requires the
+* channel to be configured in blocking mode.
+*
+* @apiNote This method is for use by the socket adaptor.
+*
+* @param nanos the timeout, in nanoseconds
+* @throws IllegalBlockingModeException if the channel is configured non-blocking
+* @throws SocketTimeoutException if the timeout expires
+*/
+SocketChannel blockingAccept(long nanos) throws IOException {
+int n = 0;
+FileDescriptor newfd = new FileDescriptor();
+InetSocketAddress[] isaa = new InetSocketAddress[1];
+acceptLock.lock();
+try {
+// check that channel is configured blocking
+if (!isBlocking())
+throw new IllegalBlockingModeException();
+try {
+begin(true);
+// change socket to non-blocking
+lockedConfigureBlocking(false);
+try {
+long startNanos = System.nanoTime();
+n = Net.accept(fd, newfd, isaa);
+while (n == IOStatus.UNAVAILABLE && isOpen()) {
+long remainingNanos = nanos - (System.nanoTime() - startNanos);
+if (remainingNanos <= 0) {
+throw new SocketTimeoutException("Accept timed out");
+}
+park(Net.POLLIN, remainingNanos);
+n = Net.accept(fd, newfd, isaa);
+}
+} finally {
+// restore socket to blocking mode
+lockedConfigureBlocking(true);
+}
+} finally {
+end(true, n > 0);
+}
+} finally {
+acceptLock.unlock();
+}
+assert n > 0;
+return finishAccept(newfd, isaa[0]);
+}
+private SocketChannel finishAccept(FileDescriptor newfd, InetSocketAddress isa)
+throws IOException
+{
 try {
 // newly accepted socket is initially in blocking mode
 IOUtil.configureBlocking(newfd, true);
 // check permitted to accept connections from the remote address
 @Override
 protected void implConfigureBlocking(boolean block) throws IOException {
 acceptLock.lock();
 try {
-synchronized (stateLock) {
+lockedConfigureBlocking(block);
-ensureOpen();
-IOUtil.configureBlocking(fd, block);
-}
 } finally {
 acceptLock.unlock();
+}
+}
+/**
+* Adjust the blocking mode while holding acceptLock.
+*/
+private void lockedConfigureBlocking(boolean block) throws IOException {
+assert acceptLock.isHeldByCurrentThread();
+stateLock.lock();
+try {
+ensureOpen();
+IOUtil.configureBlocking(fd, block);
+} finally {
+stateLock.unlock();
 }
 }
 /**
 * Invoked by implCloseChannel to close the channel.
 boolean interrupted = false;
 boolean blocking;
 // set state to ST_CLOSING
-synchronized (stateLock) {
+stateLock.lock();
+try {
 assert state < ST_CLOSING;
 state = ST_CLOSING;
 blocking = isBlocking();
+} finally {
+stateLock.unlock();
 }
 // wait for any outstanding accept to complete
 if (blocking) {
-synchronized (stateLock) {
+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 {
-stateLock.wait();
+stateCondition.await();
 } catch (InterruptedException e) {
 interrupted = true;
 }
 }
 }
+} finally {
+stateLock.unlock();
 }
 } else {
 // non-blocking mode: wait for accept to complete
 acceptLock.lock();
 acceptLock.unlock();
 }
 // set state to ST_KILLPENDING
-synchronized (stateLock) {
+stateLock.lock();
+try {
 assert state == ST_CLOSING;
 state = ST_KILLPENDING;
+} finally {
+stateLock.unlock();
 }
 // close socket if not registered with Selector
 if (!isRegistered())
 kill();
 Thread.currentThread().interrupt();
 }
 @Override
 public void kill() throws IOException {
-synchronized (stateLock) {
+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() {
-synchronized (stateLock) {
+stateLock.lock();
+try {
 return localAddress != null;
+} finally {
+stateLock.unlock();
 }
 }
 /**
 * Returns the local address, or null if not bound
 */
 InetSocketAddress localAddress() {
-synchronized (stateLock) {
+stateLock.lock();
+try {
 return localAddress;
-}
+} finally {
-}
+stateLock.unlock();
-/**
-* Poll this channel's socket for a new connection up to the given timeout.
-* @return {@code true} if there is a connection to accept
-*/
-boolean pollAccept(long timeout) throws IOException {
-assert Thread.holdsLock(blockingLock()) && isBlocking();
-acceptLock.lock();
-try {
-boolean polled = false;
-try {
-begin(true);
-int events = Net.poll(fd, Net.POLLIN, timeout);
-polled = (events != 0);
-} finally {
-end(true, polled);
-}
-return polled;
-} finally {
-acceptLock.unlock();
 }
 }
 /**
 * Translates native poll revent set into a ready operation set
 sb.append(this.getClass().getName());
 sb.append('[');
 if (!isOpen()) {
 sb.append("closed");
 } else {
-synchronized (stateLock) {
+stateLock.lock();
+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 54620	13b67c1420b8
parent 54154	1caf2daef7cf
child 54754	193a8f1a4f3b
child 57339	40fdbdd92617