8284161: Implementation of Virtual Threads (Preview)

Co-authored-by: Ron Pressler <rpressler@openjdk.org>
Co-authored-by: Alan Bateman <alanb@openjdk.org>
Co-authored-by: Erik Österlund <eosterlund@openjdk.org>
Co-authored-by: Andrew Haley <aph@openjdk.org>
Co-authored-by: Rickard Bäckman <rbackman@openjdk.org>
Co-authored-by: Markus Grönlund <mgronlun@openjdk.org>
Co-authored-by: Leonid Mesnik <lmesnik@openjdk.org>
Co-authored-by: Serguei Spitsyn <sspitsyn@openjdk.org>
Co-authored-by: Chris Plummer <cjplummer@openjdk.org>
Co-authored-by: Coleen Phillimore <coleenp@openjdk.org>
Co-authored-by: Robbin Ehn <rehn@openjdk.org>
Co-authored-by: Stefan Karlsson <stefank@openjdk.org>
Co-authored-by: Thomas Schatzl <tschatzl@openjdk.org>
Co-authored-by: Sergey Kuksenko <skuksenko@openjdk.org>
Reviewed-by: lancea, eosterlund, rehn, sspitsyn, stefank, tschatzl, dfuchs, lmesnik, dcubed, kevinw, amenkov, dlong, mchung, psandoz, bpb, coleenp, smarks, egahlin, mseledtsov, coffeys, darcy

src/java.base/share/classes/java/io/BufferedInputStream.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1994, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1994, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,7 @@
 
 package java.io;
 
+import jdk.internal.misc.InternalLock;
 import jdk.internal.misc.Unsafe;
 import jdk.internal.util.ArraysSupport;
 
@@ -63,6 +64,9 @@ public class BufferedInputStream extends FilterInputStream {
     private static final long BUF_OFFSET
             = U.objectFieldOffset(BufferedInputStream.class, "buf");
 
+    // initialized to null when BufferedInputStream is sub-classed
+    private final InternalLock lock;
+
     /**
      * The internal buffer array where the data is stored. When necessary,
      * it may be replaced by another array of
@@ -199,12 +203,19 @@ public class BufferedInputStream extends FilterInputStream {
             throw new IllegalArgumentException("Buffer size <= 0");
         }
         buf = new byte[size];
+
+        // use monitors when BufferedInputStream is sub-classed
+        if (getClass() == BufferedInputStream.class) {
+            lock = InternalLock.newLockOrNull();
+        } else {
+            lock = null;
+        }
     }
 
     /**
      * Fills the buffer with more data, taking into account
      * shuffling and other tricks for dealing with marks.
-     * Assumes that it is being called by a synchronized method.
+     * Assumes that it is being called by a locked method.
      * This method also assumes that all data has already been read in,
      * hence pos > count.
      */
@@ -258,7 +269,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                          or an I/O error occurs.
      * @see        java.io.FilterInputStream#in
      */
-    public synchronized int read() throws IOException {
+    public int read() throws IOException {
+        if (lock != null) {
+            lock.lock();
+            try {
+                return implRead();
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                return implRead();
+            }
+        }
+    }
+
+    private int implRead() throws IOException {
         if (pos >= count) {
             fill();
             if (pos >= count)
@@ -328,9 +354,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                          invoking its {@link #close()} method,
      *                          or an I/O error occurs.
      */
-    public synchronized int read(byte[] b, int off, int len)
-        throws IOException
-    {
+    public int read(byte[] b, int off, int len) throws IOException {
+        if (lock != null) {
+            lock.lock();
+            try {
+                return implRead(b, off, len);
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                return implRead(b, off, len);
+            }
+        }
+    }
+
+    private int implRead(byte[] b, int off, int len) throws IOException {
         getBufIfOpen(); // Check for closed stream
         if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
             throw new IndexOutOfBoundsException();
@@ -362,7 +401,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                      {@code in.skip(n)} throws an IOException,
      *                      or an I/O error occurs.
      */
-    public synchronized long skip(long n) throws IOException {
+    public long skip(long n) throws IOException {
+        if (lock != null) {
+            lock.lock();
+            try {
+                return implSkip(n);
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                return implSkip(n);
+            }
+        }
+    }
+
+    private long implSkip(long n) throws IOException {
         getBufIfOpen(); // Check for closed stream
         if (n <= 0) {
             return 0;
@@ -403,7 +457,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                          invoking its {@link #close()} method,
      *                          or an I/O error occurs.
      */
-    public synchronized int available() throws IOException {
+    public int available() throws IOException {
+        if (lock != null) {
+            lock.lock();
+            try {
+                return implAvailable();
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                return implAvailable();
+            }
+        }
+    }
+
+    private int implAvailable() throws IOException {
         int n = count - pos;
         int avail = getInIfOpen().available();
         return n > (Integer.MAX_VALUE - avail)
@@ -419,7 +488,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                      the mark position becomes invalid.
      * @see     java.io.BufferedInputStream#reset()
      */
-    public synchronized void mark(int readlimit) {
+    public void mark(int readlimit) {
+        if (lock != null) {
+            lock.lock();
+            try {
+                implMark(readlimit);
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                implMark(readlimit);
+            }
+        }
+    }
+
+    private void implMark(int readlimit) {
         marklimit = readlimit;
         markpos = pos;
     }
@@ -440,7 +524,22 @@ public class BufferedInputStream extends FilterInputStream {
      *                  method, or an I/O error occurs.
      * @see        java.io.BufferedInputStream#mark(int)
      */
-    public synchronized void reset() throws IOException {
+    public void reset() throws IOException {
+        if (lock != null) {
+            lock.lock();
+            try {
+                implReset();
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            synchronized (this) {
+                implReset();
+            }
+        }
+    }
+
+    private void implReset() throws IOException {
         getBufIfOpen(); // Cause exception if closed
         if (markpos < 0)
             throw new IOException("Resetting to invalid mark");