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

equal deleted inserted replaced

-:40fdbdd92617
+:9026cb618cdd
 *
 * This implementation attempts to be compatible with legacy PlainSocketImpl,
 * including behavior and exceptions that are not specified by SocketImpl.
 *
 * The underlying socket used by this SocketImpl is initially configured
-* blocking. If a connect, accept or read is attempted with a timeout then the
+* blocking. If the connect method is used to establish a connection with a
-* socket is changed to non-blocking mode. When in non-blocking mode, operations
+* timeout then the socket is configured non-blocking for the connect attempt,
-* that don't complete immediately will poll the socket.
+* and then restored to blocking mode when the connection is established.
+* If the accept or read methods are used with a timeout then the socket is
+* configured non-blocking and is never restored. When in non-blocking mode,
+* operations that don't complete immediately will poll the socket and preserve
+* the semantics of blocking operations.
 */
 public final class NioSocketImpl extends SocketImpl implements PlatformSocketImpl {
 private static final NativeDispatcher nd = new SocketDispatcher();
 // set by SocketImpl.create, protected by stateLock
 private boolean stream;
 private FileDescriptorCloser closer;
-// lazily set to true when the socket is configured non-blocking
+// set by configureNonBlockingForever when the socket changed to non-blocking
 private volatile boolean nonBlocking;
 // used by connect/read/write/accept, protected by stateLock
 private long readerThread;
 private long writerThread;
 private void park(FileDescriptor fd, int event) throws IOException {
 park(fd, event, 0);
 }
 /**
-* Configures the socket to be non-blocking (if not already non-blocking)
+* Configures the socket's blocking mode except when socket has been
-* @throws IOException if there is an I/O error changing the blocking mode
+* configured non-blocking by {@code configureNonBlockingForever}.
-*/
+* @throws IOException if closed or there is an I/O error changing the mode
-private void configureNonBlocking(FileDescriptor fd) throws IOException {
+*/
+private void configureBlocking(FileDescriptor fd, boolean block) throws IOException {
+assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();
 if (!nonBlocking) {
-assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();
+stateLock.lock();
+try {
+if (!nonBlocking) {
+ensureOpen();
+IOUtil.configureBlocking(fd, block);
+}
+} finally {
+stateLock.unlock();
+}
+}
+}
+/**
+* Configures the socket to be non-blocking. Once configured to non-blocking
+* by this method then the blocking mode cannot be changed back to blocking.
+* @throws IOException if closed or there is an I/O error changing the mode
+*/
+private void configureNonBlockingForever(FileDescriptor fd) throws IOException {
+assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();
+if (!nonBlocking) {
 stateLock.lock();
 try {
 ensureOpen();
 IOUtil.configureBlocking(fd, false);
+nonBlocking = true;
 } finally {
 stateLock.unlock();
 }
-nonBlocking = true;
 }
 }
 /**
 * Marks the beginning of a read operation that might block.
 * @throws SocketTimeoutException if the read timeout elapses
 */
 private int timedRead(FileDescriptor fd, byte[] b, int off, int len, long nanos)
 throws IOException
 {
-assert nonBlocking;
 long startNanos = System.nanoTime();
 int n = tryRead(fd, b, off, len);
 while (n == IOStatus.UNAVAILABLE && isOpen()) {
 long remainingNanos = nanos - (System.nanoTime() - startNanos);
 if (remainingNanos <= 0) {
 if (isInputClosed)
 return -1;
 int timeout = this.timeout;
 if (timeout > 0) {
 // read with timeout
-configureNonBlocking(fd);
+configureNonBlockingForever(fd);
 n = timedRead(fd, b, off, len, MILLISECONDS.toNanos(timeout));
 } else {
 // read, no timeout
 n = tryRead(fd, b, off, len);
 while (IOStatus.okayToRetry(n) && isOpen()) {
 connectLock.lock();
 try {
 boolean connected = false;
 FileDescriptor fd = beginConnect(address, port);
 try {
-if (millis > 0)
-configureNonBlocking(fd);
+// configure socket to non-blocking mode when there is a timeout
+if (millis > 0) {
+configureBlocking(fd, false);
+}
 int n = Net.connect(fd, address, port);
 if (n > 0) {
 // connection established
 connected = true;
 } else {
 polled = Net.pollConnectNow(fd);
 }
 connected = polled && isOpen();
 }
 }
+// restore socket to blocking mode
+if (connected && millis > 0) {
+configureBlocking(fd, true);
+}
 } finally {
 endConnect(fd, connected);
 }
 } finally {
 connectLock.unlock();
 FileDescriptor newfd,
 InetSocketAddress[] isaa,
 long nanos)
 throws IOException
 {
-assert nonBlocking;
 long startNanos = System.nanoTime();
 int n = Net.accept(fd, newfd, isaa);
 while (n == IOStatus.UNAVAILABLE && isOpen()) {
 long remainingNanos = nanos - (System.nanoTime() - startNanos);
 if (remainingNanos <= 0) {
 int n = 0;
 FileDescriptor fd = beginAccept();
 try {
 if (remainingNanos > 0) {
 // accept with timeout
-configureNonBlocking(fd);
+configureNonBlockingForever(fd);
 n = timedAccept(fd, newfd, isaa, remainingNanos);
 } else {
 // accept, no timeout
 n = Net.accept(fd, newfd, isaa);
 while (IOStatus.okayToRetry(n) && isOpen()) {
 if ((int) Net.getSocketOption(fd, SO_LINGER) != 0) {
 Net.shutdown(fd, Net.SHUT_WR);
 }
 } catch (IOException ignore) { }
-// interrupt and wait for kernel threads to complete I/O operations
+// interrupt and wait for threads to complete I/O operations
 long reader = readerThread;
 long writer = writerThread;
 if (reader != 0 || writer != 0) {
 nd.preClose(fd);

branch	niosocketimpl-branch
changeset 57340	9026cb618cdd
parent 57338	8684e6479b20
child 57342	5b512573ccb8