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

equal deleted inserted replaced

-:8bb7df86576a
+:3d6cee596b33
 * Disables the current thread for scheduling purposes until the socket is
 * ready for I/O, or is asynchronously closed, for up to the specified
 * waiting time.
 * @throws IOException if an I/O error occurs
 */
-private void park(int event, long nanos) throws IOException {
+private void park(FileDescriptor fd, int event, long nanos) throws IOException {
 long millis;
 if (nanos == 0) {
 millis = -1;
 } else {
 millis = MILLISECONDS.convert(nanos, NANOSECONDS);
 /**
 * Disables the current thread for scheduling purposes until the socket is
 * ready for I/O or is asynchronously closed.
 * @throws IOException if an I/O error occurs
 */
-private void park(int event) throws IOException {
+private void park(FileDescriptor fd, int event) throws IOException {
-park(event, 0);
+park(fd, event, 0);
 }
 /**
 * Ensures that the socket is configured non-blocking when a timeout is specified.
 * @throws IOException if there is an I/O error changing the blocking mode
 */
-private void maybeConfigureNonBlocking(FileDescriptor fd, int timeout)
+private void configureNonBlockingIfNeeded(FileDescriptor fd, int timeout)
 throws IOException
 {
-assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();
 if (timeout > 0 && !nonBlocking) {
+assert readLock.isHeldByCurrentThread() || writeLock.isHeldByCurrentThread();
 IOUtil.configureBlocking(fd, false);
 nonBlocking = true;
 }
 }
 */
 private FileDescriptor beginRead() throws SocketException {
 synchronized (stateLock) {
 ensureOpenAndConnected();
 readerThread = NativeThread.current();
-assert fd != null;
 return fd;
 }
 }
 /**
 * @throws SocketTimeoutException if the read timeout elapses
 */
 private int read(byte[] b, int off, int len) throws IOException {
 readLock.lock();
 try {
+int timeout = this.timeout;
 int n = 0;
 FileDescriptor fd = beginRead();
 try {
-if (isInputClosed) {
+if (isInputClosed)
 return IOStatus.EOF;
-}
+configureNonBlockingIfNeeded(fd, timeout);
-int timeout = this.timeout;
-maybeConfigureNonBlocking(fd, timeout);
 n = tryRead(fd, b, off, len);
 if (IOStatus.okayToRetry(n) && isOpen()) {
 if (timeout > 0) {
 // read with timeout
-assert nonBlocking;
 long nanos = NANOSECONDS.convert(timeout, TimeUnit.MILLISECONDS);
 do {
 long startTime = System.nanoTime();
-park(Net.POLLIN, nanos);
+park(fd, Net.POLLIN, nanos);
 n = tryRead(fd, b, off, len);
 if (n == IOStatus.UNAVAILABLE) {
 nanos -= System.nanoTime() - startTime;
 if (nanos <= 0)
 throw new SocketTimeoutException("read timeout");
 }
 } while (n == IOStatus.UNAVAILABLE && isOpen());
 } else {
 // read, no timeout
 do {
-park(Net.POLLIN);
+park(fd, Net.POLLIN);
 n = tryRead(fd, b, off, len);
 } while (IOStatus.okayToRetry(n) && isOpen());
 }
 }
 return n;
 */
 private FileDescriptor beginWrite() throws SocketException {
 synchronized (stateLock) {
 ensureOpenAndConnected();
 writerThread = NativeThread.current();
-assert fd != null;
 return fd;
 }
 }
 /**
 int n = 0;
 FileDescriptor fd = beginWrite();
 try {
 n = tryWrite(fd, b, off, len);
 while (IOStatus.okayToRetry(n) && isOpen()) {
-park(Net.POLLOUT);
+park(fd, Net.POLLOUT);
 n = tryWrite(fd, b, off, len);
 }
 return n;
 } finally {
 endWrite(n > 0);
 // save the remote address/port
 this.address = address;
 this.port = port;
 readerThread = NativeThread.current();
-assert fd != null;
 return fd;
 }
 }
 /**
 connectLock.lock();
 try {
 boolean connected = false;
 FileDescriptor fd = beginConnect(address, port);
 try {
-maybeConfigureNonBlocking(fd, millis);
+configureNonBlockingIfNeeded(fd, millis);
 int n = Net.connect(fd, address, port);
 if (IOStatus.okayToRetry(n) && isOpen()) {
 if (millis > 0) {
 // connect with timeout
 assert nonBlocking;
 long nanos = NANOSECONDS.convert(millis, MILLISECONDS);
 do {
 long startTime = System.nanoTime();
-park(Net.POLLOUT, nanos);
+park(fd, Net.POLLOUT, nanos);
 n = Net.pollConnectNow(fd);
 if (n == 0) {
 nanos -= System.nanoTime() - startTime;
 if (nanos <= 0)
 throw new SocketTimeoutException("connect timeout");
 }
 } while (n == 0 && isOpen());
 } else {
 // connect, no timeout
 do {
-park(Net.POLLOUT);
+park(fd, Net.POLLOUT);
 n = Net.pollConnectNow(fd);
 } while (n == 0 && isOpen());
 }
 }
 connected = (n > 0) && isOpen();
 if (!stream)
 throw new SocketException("Not a stream socket");
 if (localport == 0)
 throw new SocketException("Not bound");
 readerThread = NativeThread.current();
-assert fd != null;
 return fd;
 }
 }
 /**
 try {
 int n = 0;
 FileDescriptor fd = beginAccept();
 try {
 int timeout = this.timeout;
-maybeConfigureNonBlocking(fd, timeout);
+configureNonBlockingIfNeeded(fd, timeout);
 n = ServerSocketChannelImpl.accept0(fd, newfd, isaa);
 if (IOStatus.okayToRetry(n) && isOpen()) {
 if (timeout > 0) {
 // accept with timeout
 assert nonBlocking;
 long nanos = NANOSECONDS.convert(timeout, TimeUnit.MILLISECONDS);
 do {
 long startTime = System.nanoTime();
-park(Net.POLLIN, nanos);
+park(fd, Net.POLLIN, nanos);
 n = ServerSocketChannelImpl.accept0(fd, newfd, isaa);
 if (n == IOStatus.UNAVAILABLE) {
 nanos -= System.nanoTime() - startTime;
 if (nanos <= 0)
 throw new SocketTimeoutException("accept timeout");
 }
 } while (n == IOStatus.UNAVAILABLE && isOpen());
 } else {
 // accept, no timeout
 do {
-park(Net.POLLIN);
+park(fd, Net.POLLIN);
 n = ServerSocketChannelImpl.accept0(fd, newfd, isaa);
 } while (IOStatus.okayToRetry(n) && isOpen());
 }
 }
 } finally {
 }
 @Override
 protected InputStream getInputStream() {
 return new InputStream() {
-private volatile boolean eof;
+private volatile boolean eof;  // to emulate legacy SocketInputStream
 @Override
 public int read() throws IOException {
 byte[] a = new byte[1];
 int n = read(a, 0, 1);
 return (n > 0) ? (a[0] & 0xff) : -1;
 }
 @Override
 public int read(byte[] b, int off, int len) throws IOException {
 Objects.checkFromIndexSize(off, len, b.length);
 if (eof) {
-return -1;
+return -1; // return -1, even if socket is closed
 } else if (len == 0) {
-return 0;
+return 0;  // return 0, even if socket is closed
 } else {
 try {
 // read up to MAX_BUFFER_SIZE bytes
 int size = Math.min(len, MAX_BUFFER_SIZE);
 int n = NioSocketImpl.this.read(b, off, size);
 writeLock.lock();
 try {
 int n = 0;
 FileDescriptor fd = beginWrite();
 try {
-maybeConfigureNonBlocking(fd, 0);
 do {
 n = Net.sendOOB(fd, (byte) data);
 } while (n == IOStatus.INTERRUPTED && isOpen());
 if (n == IOStatus.UNAVAILABLE) {
 throw new RuntimeException("not implemented yet");

branch	niosocketimpl-branch
changeset 57128	3d6cee596b33
parent 57124	8bb7df86576a
child 57172	63ab5af5d009