Skip to content

Commit ca477f7

Browse files
AlanBatemanAlanBateman
committedFeb 7, 2021
lock cleanup
·
JEP-429-branchpoint
1 parent b4409d9 commit ca477f7

14 files changed

+209
-230
lines changed
 

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

+3-3
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@
2525

2626
package java.io;
2727

28-
import java.util.concurrent.locks.ReentrantLock;
28+
import jdk.internal.misc.InternalLock;
2929
import jdk.internal.misc.Unsafe;
3030
import jdk.internal.util.ArraysSupport;
3131

@@ -65,7 +65,7 @@ public class BufferedInputStream extends FilterInputStream {
6565
= U.objectFieldOffset(BufferedInputStream.class, "buf");
6666

6767
// initialized to null when BufferedInputStream is sub-classed
68-
private final ReentrantLock lock;
68+
private final InternalLock lock;
6969

7070
/**
7171
* The internal buffer array where the data is stored. When necessary,
@@ -206,7 +206,7 @@ public BufferedInputStream(InputStream in, int size) {
206206

207207
// use monitors when BufferedInputStream is sub-classed
208208
if (getClass() == BufferedInputStream.class) {
209-
lock = new ReentrantLock();
209+
lock = new InternalLock();
210210
} else {
211211
lock = null;
212212
}

‎src/java.base/share/classes/java/io/BufferedOutputStream.java

+4-4
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@
2626
package java.io;
2727

2828
import java.util.Arrays;
29-
import java.util.concurrent.locks.ReentrantLock;
29+
import jdk.internal.misc.InternalLock;
3030
import jdk.internal.misc.VM;
3131

3232
/**
@@ -43,7 +43,7 @@ public class BufferedOutputStream extends FilterOutputStream {
4343
private static final int DEFAULT_MAX_BUFFER_SIZE = 8192;
4444

4545
// initialized to null when BufferedOutputStream is sub-classed
46-
private final ReentrantLock lock;
46+
private final InternalLock lock;
4747

4848
/**
4949
* The internal buffer where data is stored.
@@ -85,8 +85,8 @@ private BufferedOutputStream(OutputStream out, int initialSize, int maxSize) {
8585
}
8686

8787
if (getClass() == BufferedOutputStream.class) {
88-
// use ReentrantLock and resizable buffer when not sub-classed
89-
this.lock = new ReentrantLock();
88+
// use ExplicitLock and resizable buffer when not sub-classed
89+
this.lock = new InternalLock();
9090
this.buf = new byte[initialSize]; // resizable
9191
this.maxBufSize = maxSize;
9292
} else {

‎src/java.base/share/classes/java/io/BufferedReader.java

+27-37
Original file line numberDiff line numberDiff line change
@@ -25,15 +25,13 @@
2525

2626
package java.io;
2727

28-
2928
import java.util.Iterator;
3029
import java.util.NoSuchElementException;
3130
import java.util.Spliterator;
3231
import java.util.Spliterators;
33-
import java.util.concurrent.locks.Lock;
34-
import java.util.concurrent.locks.ReentrantLock;
3532
import java.util.stream.Stream;
3633
import java.util.stream.StreamSupport;
34+
import jdk.internal.misc.InternalLock;
3735

3836
/**
3937
* Reads text from a character-input stream, buffering characters so as to
@@ -107,9 +105,9 @@ public BufferedReader(Reader in, int sz) {
107105
cb = new char[sz];
108106
nextChar = nChars = 0;
109107

110-
// use ReentrantLock when BufferedReader is not sub-classed
108+
// use ExplicitLock when BufferedReader is not sub-classed
111109
if (getClass() == BufferedReader.class) {
112-
lock = new ReentrantLock();
110+
lock = new InternalLock();
113111
}
114112
}
115113

@@ -183,13 +181,12 @@ private void fill() throws IOException {
183181
*/
184182
public int read() throws IOException {
185183
Object lock = this.lock;
186-
if (lock instanceof Lock) {
187-
Lock theLock = (Lock) lock;
188-
theLock.lock();
184+
if (lock instanceof InternalLock locker) {
185+
locker.lock();
189186
try {
190187
return lockedRead();
191188
} finally {
192-
theLock.unlock();
189+
locker.unlock();
193190
}
194191
} else {
195192
synchronized (lock) {
@@ -298,13 +295,12 @@ private int read1(char[] cbuf, int off, int len) throws IOException {
298295
*/
299296
public int read(char cbuf[], int off, int len) throws IOException {
300297
Object lock = this.lock;
301-
if (lock instanceof Lock) {
302-
Lock theLock = (Lock) lock;
303-
theLock.lock();
298+
if (lock instanceof InternalLock locker) {
299+
locker.lock();
304300
try {
305301
return lockedRead(cbuf, off, len);
306302
} finally {
307-
theLock.unlock();
303+
locker.unlock();
308304
}
309305
} else {
310306
synchronized (lock) {
@@ -352,13 +348,12 @@ private int lockedRead(char cbuf[], int off, int len) throws IOException {
352348
*/
353349
String readLine(boolean ignoreLF, boolean[] term) throws IOException {
354350
Object lock = this.lock;
355-
if (lock instanceof Lock) {
356-
Lock theLock = (Lock) lock;
357-
theLock.lock();
351+
if (lock instanceof InternalLock locker) {
352+
locker.lock();
358353
try {
359354
return lockedReadLine(ignoreLF, term);
360355
} finally {
361-
theLock.unlock();
356+
locker.unlock();
362357
}
363358
} else {
364359
synchronized (lock) {
@@ -463,13 +458,12 @@ public long skip(long n) throws IOException {
463458
throw new IllegalArgumentException("skip value is negative");
464459
}
465460
Object lock = this.lock;
466-
if (lock instanceof Lock) {
467-
Lock theLock = (Lock) lock;
468-
theLock.lock();
461+
if (lock instanceof InternalLock locker) {
462+
locker.lock();
469463
try {
470464
return lockedSkip(n);
471465
} finally {
472-
theLock.unlock();
466+
locker.unlock();
473467
}
474468
} else {
475469
synchronized (lock) {
@@ -515,13 +509,12 @@ private long lockedSkip(long n) throws IOException {
515509
*/
516510
public boolean ready() throws IOException {
517511
Object lock = this.lock;
518-
if (lock instanceof Lock) {
519-
Lock theLock = (Lock) lock;
520-
theLock.lock();
512+
if (lock instanceof InternalLock locker) {
513+
locker.lock();
521514
try {
522515
return lockedReady();
523516
} finally {
524-
theLock.unlock();
517+
locker.unlock();
525518
}
526519
} else {
527520
synchronized (lock) {
@@ -581,13 +574,12 @@ public void mark(int readAheadLimit) throws IOException {
581574
throw new IllegalArgumentException("Read-ahead limit < 0");
582575
}
583576
Object lock = this.lock;
584-
if (lock instanceof Lock) {
585-
Lock theLock = (Lock) lock;
586-
theLock.lock();
577+
if (lock instanceof InternalLock locker) {
578+
locker.lock();
587579
try {
588580
lockedMark(readAheadLimit);
589581
} finally {
590-
theLock.unlock();
582+
locker.unlock();
591583
}
592584
} else {
593585
synchronized (lock) {
@@ -611,13 +603,12 @@ private void lockedMark(int readAheadLimit) throws IOException {
611603
*/
612604
public void reset() throws IOException {
613605
Object lock = this.lock;
614-
if (lock instanceof Lock) {
615-
Lock theLock = (Lock) lock;
616-
theLock.lock();
606+
if (lock instanceof InternalLock locker) {
607+
locker.lock();
617608
try {
618609
lockedReset();
619610
} finally {
620-
theLock.unlock();
611+
locker.unlock();
621612
}
622613
} else {
623614
synchronized (lock) {
@@ -638,13 +629,12 @@ private void lockedReset() throws IOException {
638629

639630
public void close() throws IOException {
640631
Object lock = this.lock;
641-
if (lock instanceof Lock) {
642-
Lock theLock = (Lock) lock;
643-
theLock.lock();
632+
if (lock instanceof InternalLock locker) {
633+
locker.lock();
644634
try {
645635
lockedClose();
646636
} finally {
647-
theLock.unlock();
637+
locker.unlock();
648638
}
649639
} else {
650640
synchronized (lock) {

‎src/java.base/share/classes/java/io/BufferedWriter.java

+21-28
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,7 @@
2626
package java.io;
2727

2828
import java.util.Arrays;
29-
import java.util.concurrent.locks.Lock;
30-
import java.util.concurrent.locks.ReentrantLock;
29+
import jdk.internal.misc.InternalLock;
3130
import jdk.internal.misc.VM;
3231

3332
/**
@@ -103,9 +102,9 @@ private BufferedWriter(Writer out, int initialSize, int maxSize) {
103102
this.nChars = initialSize;
104103
this.maxChars = maxSize;
105104

106-
// use ReentrantLock when BufferedWriter is not sub-classed
105+
// use ExplicitLock when BufferedWriter is not sub-classed
107106
if (getClass() == BufferedWriter.class) {
108-
this.lock = new ReentrantLock();
107+
this.lock = new InternalLock();
109108
}
110109
}
111110

@@ -159,13 +158,12 @@ private void growIfNeeded(int len) {
159158
*/
160159
void flushBuffer() throws IOException {
161160
Object lock = this.lock;
162-
if (lock instanceof Lock) {
163-
Lock theLock = (Lock) lock;
164-
theLock.lock();
161+
if (lock instanceof InternalLock locker) {
162+
locker.lock();
165163
try {
166164
lockedFlushBuffer();
167165
} finally {
168-
theLock.unlock();
166+
locker.unlock();
169167
}
170168
} else {
171169
synchronized (lock) {
@@ -189,13 +187,12 @@ private void lockedFlushBuffer() throws IOException {
189187
*/
190188
public void write(int c) throws IOException {
191189
Object lock = this.lock;
192-
if (lock instanceof Lock) {
193-
Lock theLock = (Lock) lock;
194-
theLock.lock();
190+
if (lock instanceof InternalLock locker) {
191+
locker.lock();
195192
try {
196193
lockedWrite(c);
197194
} finally {
198-
theLock.unlock();
195+
locker.unlock();
199196
}
200197
} else {
201198
synchronized (lock) {
@@ -244,13 +241,12 @@ private int min(int a, int b) {
244241
*/
245242
public void write(char cbuf[], int off, int len) throws IOException {
246243
Object lock = this.lock;
247-
if (lock instanceof Lock) {
248-
Lock theLock = (Lock) lock;
249-
theLock.lock();
244+
if (lock instanceof InternalLock locker) {
245+
locker.lock();
250246
try {
251247
lockedWrite(cbuf, off, len);
252248
} finally {
253-
theLock.unlock();
249+
locker.unlock();
254250
}
255251
} else {
256252
synchronized (lock) {
@@ -314,13 +310,12 @@ private void lockedWrite(char cbuf[], int off, int len) throws IOException {
314310
*/
315311
public void write(String s, int off, int len) throws IOException {
316312
Object lock = this.lock;
317-
if (lock instanceof Lock) {
318-
Lock theLock = (Lock) lock;
319-
theLock.lock();
313+
if (lock instanceof InternalLock locker) {
314+
locker.lock();
320315
try {
321316
lockedWrite(s, off, len);
322317
} finally {
323-
theLock.unlock();
318+
locker.unlock();
324319
}
325320
} else {
326321
synchronized (lock) {
@@ -361,13 +356,12 @@ public void newLine() throws IOException {
361356
*/
362357
public void flush() throws IOException {
363358
Object lock = this.lock;
364-
if (lock instanceof Lock) {
365-
Lock theLock = (Lock) lock;
366-
theLock.lock();
359+
if (lock instanceof InternalLock locker) {
360+
locker.lock();
367361
try {
368362
lockedFlush();
369363
} finally {
370-
theLock.unlock();
364+
locker.unlock();
371365
}
372366
} else {
373367
synchronized (lock) {
@@ -383,13 +377,12 @@ private void lockedFlush() throws IOException {
383377

384378
public void close() throws IOException {
385379
Object lock = this.lock;
386-
if (lock instanceof Lock) {
387-
Lock theLock = (Lock) lock;
388-
theLock.lock();
380+
if (lock instanceof InternalLock locker) {
381+
locker.lock();
389382
try {
390383
lockedClose();
391384
} finally {
392-
theLock.unlock();
385+
locker.unlock();
393386
}
394387
} else {
395388
synchronized (lock) {

‎src/java.base/share/classes/java/io/InputStreamReader.java

+2-4
Original file line numberDiff line numberDiff line change
@@ -27,11 +27,9 @@
2727

2828
import java.nio.charset.Charset;
2929
import java.nio.charset.CharsetDecoder;
30-
import java.util.concurrent.locks.ReentrantLock;
31-
30+
import jdk.internal.misc.InternalLock;
3231
import sun.nio.cs.StreamDecoder;
3332

34-
3533
/**
3634
* An InputStreamReader is a bridge from byte streams to character streams: It
3735
* reads bytes and decodes them into characters using a specified {@link
@@ -67,7 +65,7 @@ public class InputStreamReader extends Reader {
6765

6866
private static Object lockFor(InputStreamReader reader) {
6967
if (reader.getClass() == InputStreamReader.class) {
70-
return new ReentrantLock();
68+
return new InternalLock();
7169
} else {
7270
return reader;
7371
}

‎src/java.base/share/classes/java/io/OutputStreamWriter.java

+2-4
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,9 @@
2828
import java.nio.CharBuffer;
2929
import java.nio.charset.Charset;
3030
import java.nio.charset.CharsetEncoder;
31-
import java.util.concurrent.locks.ReentrantLock;
32-
31+
import jdk.internal.misc.InternalLock;
3332
import sun.nio.cs.StreamEncoder;
3433

35-
3634
/**
3735
* An OutputStreamWriter is a bridge from character streams to byte streams:
3836
* Characters written to it are encoded into bytes using a specified {@link
@@ -81,7 +79,7 @@ public class OutputStreamWriter extends Writer {
8179

8280
private static Object lockFor(OutputStreamWriter writer) {
8381
if (writer.getClass() == OutputStreamWriter.class) {
84-
return new ReentrantLock();
82+
return new InternalLock();
8583
} else {
8684
return writer;
8785
}

‎src/java.base/share/classes/java/io/PrintStream.java

+4-4
Original file line numberDiff line numberDiff line change
@@ -30,9 +30,9 @@
3030
import java.nio.charset.Charset;
3131
import java.nio.charset.IllegalCharsetNameException;
3232
import java.nio.charset.UnsupportedCharsetException;
33-
import java.util.concurrent.locks.ReentrantLock;
3433
import jdk.internal.access.JavaIOPrintStreamAccess;
3534
import jdk.internal.access.SharedSecrets;
35+
import jdk.internal.misc.InternalLock;
3636

3737
/**
3838
* A {@code PrintStream} adds functionality to another output stream,
@@ -67,7 +67,7 @@ public class PrintStream extends FilterOutputStream
6767
implements Appendable, Closeable
6868
{
6969
// initialized to null when PrintStream is sub-classed
70-
private final ReentrantLock lock;
70+
private final InternalLock lock;
7171

7272
private final boolean autoFlush;
7373
private boolean trouble = false;
@@ -117,7 +117,7 @@ private PrintStream(boolean autoFlush, OutputStream out) {
117117

118118
// use monitors when PrintStream is sub-classed
119119
if (getClass() == PrintStream.class) {
120-
lock = new ReentrantLock();
120+
lock = new InternalLock();
121121
} else {
122122
lock = null;
123123
}
@@ -213,7 +213,7 @@ public PrintStream(OutputStream out, boolean autoFlush, Charset charset) {
213213

214214
// use monitors when PrintStream is sub-classed
215215
if (getClass() == PrintStream.class) {
216-
lock = new ReentrantLock();
216+
lock = new InternalLock();
217217
} else {
218218
lock = null;
219219
}

‎src/java.base/share/classes/java/io/PrintWriter.java

+54-72
Original file line numberDiff line numberDiff line change
@@ -31,10 +31,9 @@
3131
import java.nio.charset.Charset;
3232
import java.nio.charset.IllegalCharsetNameException;
3333
import java.nio.charset.UnsupportedCharsetException;
34-
import java.util.concurrent.locks.Lock;
35-
import java.util.concurrent.locks.ReentrantLock;
3634
import jdk.internal.access.JavaIOPrintWriterAccess;
3735
import jdk.internal.access.SharedSecrets;
36+
import jdk.internal.misc.InternalLock;
3837

3938
/**
4039
* Prints formatted representations of objects to a text-output stream. This
@@ -117,9 +116,9 @@ public PrintWriter(Writer out,
117116
this.out = out;
118117
this.autoFlush = autoFlush;
119118

120-
// use ReentrantLock when PrintWriter is not sub-classed
119+
// use ExplicitLock when PrintWriter is not sub-classed
121120
if (getClass() == PrintWriter.class) {
122-
this.lock = new ReentrantLock();
121+
this.lock = new InternalLock();
123122
}
124123
}
125124

@@ -400,13 +399,12 @@ private void ensureOpen() throws IOException {
400399
*/
401400
public void flush() {
402401
Object lock = this.lock;
403-
if (lock instanceof Lock) {
404-
Lock theLock = (Lock) lock;
405-
theLock.lock();
402+
if (lock instanceof InternalLock locker) {
403+
locker.lock();
406404
try {
407405
lockedFlush();
408406
} finally {
409-
theLock.unlock();
407+
locker.unlock();
410408
}
411409
} else {
412410
synchronized (lock) {
@@ -432,13 +430,12 @@ private void lockedFlush() {
432430
*/
433431
public void close() {
434432
Object lock = this.lock;
435-
if (lock instanceof Lock) {
436-
Lock theLock = (Lock) lock;
437-
theLock.lock();
433+
if (lock instanceof InternalLock locker) {
434+
locker.lock();
438435
try {
439436
lockedClose();
440437
} finally {
441-
theLock.unlock();
438+
locker.unlock();
442439
}
443440
} else {
444441
synchronized (lock) {
@@ -513,13 +510,12 @@ protected void clearError() {
513510
*/
514511
public void write(int c) {
515512
Object lock = this.lock;
516-
if (lock instanceof Lock) {
517-
Lock theLock = (Lock) lock;
518-
theLock.lock();
513+
if (lock instanceof InternalLock locker) {
514+
locker.lock();
519515
try {
520516
lockedWrite(c);
521517
} finally {
522-
theLock.unlock();
518+
locker.unlock();
523519
}
524520
} else {
525521
synchronized (lock) {
@@ -552,13 +548,12 @@ private void lockedWrite(int c) {
552548
*/
553549
public void write(char buf[], int off, int len) {
554550
Object lock = this.lock;
555-
if (lock instanceof Lock) {
556-
Lock theLock = (Lock) lock;
557-
theLock.lock();
551+
if (lock instanceof InternalLock locker) {
552+
locker.lock();
558553
try {
559554
lockedWrite(buf, off, len);
560555
} finally {
561-
theLock.unlock();
556+
locker.unlock();
562557
}
563558
} else {
564559
synchronized (lock) {
@@ -600,13 +595,12 @@ public void write(char buf[]) {
600595
*/
601596
public void write(String s, int off, int len) {
602597
Object lock = this.lock;
603-
if (lock instanceof Lock) {
604-
Lock theLock = (Lock) lock;
605-
theLock.lock();
598+
if (lock instanceof InternalLock locker) {
599+
locker.lock();
606600
try {
607601
lockedWrite(s, off, len);
608602
} finally {
609-
theLock.unlock();
603+
locker.unlock();
610604
}
611605
} else {
612606
synchronized (lock) {
@@ -637,13 +631,12 @@ public void write(String s) {
637631

638632
private void newLine() {
639633
Object lock = this.lock;
640-
if (lock instanceof Lock) {
641-
Lock theLock = (Lock) lock;
642-
theLock.lock();
634+
if (lock instanceof InternalLock locker) {
635+
locker.lock();
643636
try {
644637
lockedNewLine();
645638
} finally {
646-
theLock.unlock();
639+
locker.unlock();
647640
}
648641
} else {
649642
synchronized (lock) {
@@ -809,14 +802,13 @@ public void println() {
809802
*/
810803
public void println(boolean x) {
811804
Object lock = this.lock;
812-
if (lock instanceof Lock) {
813-
Lock theLock = (Lock) lock;
814-
theLock.lock();
805+
if (lock instanceof InternalLock locker) {
806+
locker.lock();
815807
try {
816808
print(x);
817809
println();
818810
} finally {
819-
theLock.unlock();
811+
locker.unlock();
820812
}
821813
} else {
822814
synchronized (lock) {
@@ -835,14 +827,13 @@ public void println(boolean x) {
835827
*/
836828
public void println(char x) {
837829
Object lock = this.lock;
838-
if (lock instanceof Lock) {
839-
Lock theLock = (Lock) lock;
840-
theLock.lock();
830+
if (lock instanceof InternalLock locker) {
831+
locker.lock();
841832
try {
842833
print(x);
843834
println();
844835
} finally {
845-
theLock.unlock();
836+
locker.unlock();
846837
}
847838
} else {
848839
synchronized (lock) {
@@ -861,14 +852,13 @@ public void println(char x) {
861852
*/
862853
public void println(int x) {
863854
Object lock = this.lock;
864-
if (lock instanceof Lock) {
865-
Lock theLock = (Lock) lock;
866-
theLock.lock();
855+
if (lock instanceof InternalLock locker) {
856+
locker.lock();
867857
try {
868858
print(x);
869859
println();
870860
} finally {
871-
theLock.unlock();
861+
locker.unlock();
872862
}
873863
} else {
874864
synchronized (lock) {
@@ -887,14 +877,13 @@ public void println(int x) {
887877
*/
888878
public void println(long x) {
889879
Object lock = this.lock;
890-
if (lock instanceof Lock) {
891-
Lock theLock = (Lock) lock;
892-
theLock.lock();
880+
if (lock instanceof InternalLock locker) {
881+
locker.lock();
893882
try {
894883
print(x);
895884
println();
896885
} finally {
897-
theLock.unlock();
886+
locker.unlock();
898887
}
899888
} else {
900889
synchronized (lock) {
@@ -913,14 +902,13 @@ public void println(long x) {
913902
*/
914903
public void println(float x) {
915904
Object lock = this.lock;
916-
if (lock instanceof Lock) {
917-
Lock theLock = (Lock) lock;
918-
theLock.lock();
905+
if (lock instanceof InternalLock locker) {
906+
locker.lock();
919907
try {
920908
print(x);
921909
println();
922910
} finally {
923-
theLock.unlock();
911+
locker.unlock();
924912
}
925913
} else {
926914
synchronized (lock) {
@@ -939,14 +927,13 @@ public void println(float x) {
939927
*/
940928
public void println(double x) {
941929
Object lock = this.lock;
942-
if (lock instanceof Lock) {
943-
Lock theLock = (Lock) lock;
944-
theLock.lock();
930+
if (lock instanceof InternalLock locker) {
931+
locker.lock();
945932
try {
946933
print(x);
947934
println();
948935
} finally {
949-
theLock.unlock();
936+
locker.unlock();
950937
}
951938
} else {
952939
synchronized (lock) {
@@ -965,14 +952,13 @@ public void println(double x) {
965952
*/
966953
public void println(char x[]) {
967954
Object lock = this.lock;
968-
if (lock instanceof Lock) {
969-
Lock theLock = (Lock) lock;
970-
theLock.lock();
955+
if (lock instanceof InternalLock locker) {
956+
locker.lock();
971957
try {
972958
print(x);
973959
println();
974960
} finally {
975-
theLock.unlock();
961+
locker.unlock();
976962
}
977963
} else {
978964
synchronized (lock) {
@@ -991,14 +977,13 @@ public void println(char x[]) {
991977
*/
992978
public void println(String x) {
993979
Object lock = this.lock;
994-
if (lock instanceof Lock) {
995-
Lock theLock = (Lock) lock;
996-
theLock.lock();
980+
if (lock instanceof InternalLock locker) {
981+
locker.lock();
997982
try {
998983
print(x);
999984
println();
1000985
} finally {
1001-
theLock.unlock();
986+
locker.unlock();
1002987
}
1003988
} else {
1004989
synchronized (lock) {
@@ -1020,14 +1005,13 @@ public void println(String x) {
10201005
public void println(Object x) {
10211006
String s = String.valueOf(x);
10221007
Object lock = this.lock;
1023-
if (lock instanceof Lock) {
1024-
Lock theLock = (Lock) lock;
1025-
theLock.lock();
1008+
if (lock instanceof InternalLock locker) {
1009+
locker.lock();
10261010
try {
10271011
print(s);
10281012
println();
10291013
} finally {
1030-
theLock.unlock();
1014+
locker.unlock();
10311015
}
10321016
} else {
10331017
synchronized (lock) {
@@ -1180,13 +1164,12 @@ public PrintWriter printf(Locale l, String format, Object ... args) {
11801164
*/
11811165
public PrintWriter format(String format, Object ... args) {
11821166
Object lock = this.lock;
1183-
if (lock instanceof Lock) {
1184-
Lock theLock = (Lock) lock;
1185-
theLock.lock();
1167+
if (lock instanceof InternalLock locker) {
1168+
locker.lock();
11861169
try {
11871170
lockedFormat(format, args);
11881171
} finally {
1189-
theLock.unlock();
1172+
locker.unlock();
11901173
}
11911174
} else {
11921175
synchronized (lock) {
@@ -1255,13 +1238,12 @@ private void lockedFormat(String format, Object ... args) {
12551238
*/
12561239
public PrintWriter format(Locale l, String format, Object ... args) {
12571240
Object lock = this.lock;
1258-
if (lock instanceof Lock) {
1259-
Lock theLock = (Lock) lock;
1260-
theLock.lock();
1241+
if (lock instanceof InternalLock locker) {
1242+
locker.lock();
12611243
try {
12621244
lockedFormat(l, format, args);
12631245
} finally {
1264-
theLock.unlock();
1246+
locker.unlock();
12651247
}
12661248
} else {
12671249
synchronized (lock) {

‎src/java.base/share/classes/java/io/Reader.java

+4-7
Original file line numberDiff line numberDiff line change
@@ -25,11 +25,9 @@
2525

2626
package java.io;
2727

28-
2928
import java.nio.CharBuffer;
3029
import java.util.Objects;
31-
import java.util.concurrent.locks.Lock;
32-
import java.util.concurrent.locks.ReentrantLock;
30+
import jdk.internal.misc.InternalLock;
3331

3432
/**
3533
* Abstract class for reading character streams. The only methods that a
@@ -283,13 +281,12 @@ public long skip(long n) throws IOException {
283281
if (n < 0L)
284282
throw new IllegalArgumentException("skip value is negative");
285283
Object lock = this.lock;
286-
if (lock instanceof Lock) {
287-
Lock theLock = (Lock) lock;
288-
theLock.lock();
284+
if (lock instanceof InternalLock locker) {
285+
locker.lock();
289286
try {
290287
return lockedSkip(n);
291288
} finally {
292-
theLock.unlock();
289+
locker.unlock();
293290
}
294291
} else {
295292
synchronized (lock) {

‎src/java.base/share/classes/java/io/Writer.java

+1-4
Original file line numberDiff line numberDiff line change
@@ -160,10 +160,7 @@ protected Writer() {
160160
* Object to synchronize on
161161
*/
162162
protected Writer(Object lock) {
163-
if (lock == null) {
164-
throw new NullPointerException();
165-
}
166-
this.lock = lock;
163+
this.lock = Objects.requireNonNull(lock);
167164
}
168165

169166
/**

‎src/java.base/share/classes/java/lang/Throwable.java

+6-7
Original file line numberDiff line numberDiff line change
@@ -27,8 +27,8 @@
2727

2828
import java.io.*;
2929
import java.util.*;
30-
import java.util.concurrent.locks.ReentrantLock;
3130
import jdk.internal.access.SharedSecrets;
31+
import jdk.internal.misc.InternalLock;
3232

3333
/**
3434
* The {@code Throwable} class is the superclass of all errors and
@@ -663,13 +663,12 @@ public void printStackTrace(PrintStream s) {
663663

664664
private void printStackTrace(PrintStreamOrWriter s) {
665665
Object lock = s.lock();
666-
if (lock instanceof ReentrantLock) {
667-
ReentrantLock l = (ReentrantLock) lock;
668-
l.lock();
666+
if (lock instanceof InternalLock locker) {
667+
locker.lock();
669668
try {
670669
lockedPrintStackTrace(s);
671670
} finally {
672-
l.unlock();
671+
locker.unlock();
673672
}
674673
} else synchronized (lock) {
675674
lockedPrintStackTrace(s);
@@ -761,8 +760,8 @@ private abstract static class PrintStreamOrWriter {
761760

762761
boolean isLockedByCurrentThread() {
763762
Object lock = lock();
764-
if (lock instanceof ReentrantLock) {
765-
return ((ReentrantLock) lock).isHeldByCurrentThread();
763+
if (lock instanceof InternalLock locker) {
764+
return locker.isHeldByCurrentThread();
766765
} else {
767766
return Thread.holdsLock(lock);
768767
}

‎src/java.base/share/classes/jdk/internal/misc/InternalLock.java

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
/*
2+
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation. Oracle designates this
8+
* particular file as subject to the "Classpath" exception as provided
9+
* by Oracle in the LICENSE file that accompanied this code.
10+
*
11+
* This code is distributed in the hope that it will be useful, but WITHOUT
12+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+
* version 2 for more details (a copy is included in the LICENSE file that
15+
* accompanied this code).
16+
*
17+
* You should have received a copy of the GNU General Public License version
18+
* 2 along with this work; if not, write to the Free Software Foundation,
19+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+
*
21+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+
* or visit www.oracle.com if you need additional information or have any
23+
* questions.
24+
*/
25+
26+
package jdk.internal.misc;
27+
28+
import java.util.concurrent.locks.ReentrantLock;
29+
30+
/**
31+
* ??
32+
*/
33+
34+
public class InternalLock {
35+
private final ReentrantLock lock = new ReentrantLock();
36+
37+
public InternalLock() { }
38+
39+
public void lock() {
40+
lock.lock();
41+
}
42+
43+
public void unlock() {
44+
lock.unlock();
45+
}
46+
47+
public boolean isHeldByCurrentThread() {
48+
return lock.isHeldByCurrentThread();
49+
}
50+
}

‎src/java.base/share/classes/sun/nio/cs/StreamDecoder.java

+13-27
Original file line numberDiff line numberDiff line change
@@ -42,16 +42,14 @@
4242
import java.nio.charset.CoderResult;
4343
import java.nio.charset.CodingErrorAction;
4444
import java.nio.charset.IllegalCharsetNameException;
45-
import java.util.concurrent.locks.ReentrantLock;
45+
import jdk.internal.misc.InternalLock;
4646

4747
public class StreamDecoder extends Reader
4848
{
4949

5050
private static final int MIN_BYTE_BUFFER_SIZE = 32;
5151
private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192;
5252

53-
private final ReentrantLock decoderLock;
54-
5553
private volatile boolean closed;
5654

5755
private void ensureOpen() throws IOException {
@@ -126,12 +124,12 @@ public int read() throws IOException {
126124
}
127125

128126
private int read0() throws IOException {
129-
if (decoderLock != null) {
130-
decoderLock.lock();
127+
if (lock instanceof InternalLock locker) {
128+
locker.lock();
131129
try {
132130
return lockedRead0();
133131
} finally {
134-
decoderLock.unlock();
132+
locker.unlock();
135133
}
136134
} else {
137135
synchronized (lock) {
@@ -167,12 +165,12 @@ private int lockedRead0() throws IOException {
167165
}
168166

169167
public int read(char cbuf[], int offset, int length) throws IOException {
170-
if (decoderLock != null) {
171-
decoderLock.lock();
168+
if (lock instanceof InternalLock locker) {
169+
locker.lock();
172170
try {
173171
return lockedRead(cbuf, offset, length);
174172
} finally {
175-
decoderLock.unlock();
173+
locker.unlock();
176174
}
177175
} else {
178176
synchronized (lock) {
@@ -219,12 +217,12 @@ private int lockedRead(char cbuf[], int offset, int length) throws IOException {
219217
}
220218

221219
public boolean ready() throws IOException {
222-
if (decoderLock != null) {
223-
decoderLock.lock();
220+
if (lock instanceof InternalLock locker) {
221+
locker.lock();
224222
try {
225223
return lockedReady();
226224
} finally {
227-
decoderLock.unlock();
225+
locker.unlock();
228226
}
229227
} else {
230228
synchronized (lock) {
@@ -239,12 +237,12 @@ private boolean lockedReady() throws IOException {
239237
}
240238

241239
public void close() throws IOException {
242-
if (decoderLock != null) {
243-
decoderLock.lock();
240+
if (lock instanceof InternalLock locker) {
241+
locker.lock();
244242
try {
245243
lockedClose();
246244
} finally {
247-
decoderLock.unlock();
245+
locker.unlock();
248246
}
249247
} else {
250248
synchronized (lock) {
@@ -319,12 +317,6 @@ private static FileChannel getChannel(FileInputStream in) {
319317
bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);
320318
}
321319
bb.flip(); // So that bb is initially empty
322-
323-
if (lock instanceof ReentrantLock) {
324-
decoderLock = (ReentrantLock) lock;
325-
} else {
326-
decoderLock = null;
327-
}
328320
}
329321

330322
StreamDecoder(ReadableByteChannel ch, CharsetDecoder dec, int mbc) {
@@ -338,12 +330,6 @@ private static FileChannel getChannel(FileInputStream in) {
338330
? MIN_BYTE_BUFFER_SIZE
339331
: mbc));
340332
bb.flip();
341-
342-
if (lock instanceof ReentrantLock) {
343-
decoderLock = (ReentrantLock) lock;
344-
} else {
345-
decoderLock = null;
346-
}
347333
}
348334

349335
private int readBytes() throws IOException {

‎src/java.base/share/classes/sun/nio/cs/StreamEncoder.java

+18-29
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,6 @@
2525

2626
package sun.nio.cs;
2727

28-
import java.io.FileOutputStream;
2928
import java.io.IOException;
3029
import java.io.OutputStream;
3130
import java.io.UnsupportedEncodingException;
@@ -38,15 +37,13 @@
3837
import java.nio.charset.CoderResult;
3938
import java.nio.charset.CodingErrorAction;
4039
import java.nio.charset.IllegalCharsetNameException;
41-
import java.util.concurrent.locks.ReentrantLock;
40+
import jdk.internal.misc.InternalLock;
4241

4342
public final class StreamEncoder extends Writer {
4443

4544
private static final int INITIAL_BYTE_BUFFER_CAPACITY = 512;
4645
private static final int MAX_BYTE_BUFFER_CAPACITY= 8192;
4746

48-
private final ReentrantLock encoderLock;
49-
5047
private volatile boolean closed;
5148

5249
private void ensureOpen() throws IOException {
@@ -108,12 +105,12 @@ public String getEncoding() {
108105
}
109106

110107
public void flushBuffer() throws IOException {
111-
if (encoderLock != null) {
112-
encoderLock.lock();
108+
if (lock instanceof InternalLock locker) {
109+
locker.lock();
113110
try {
114111
lockedFlushBuffer();
115112
} finally {
116-
encoderLock.unlock();
113+
locker.unlock();
117114
}
118115
} else {
119116
synchronized (super.lock) {
@@ -136,12 +133,12 @@ public void write(int c) throws IOException {
136133
}
137134

138135
public void write(char cbuf[], int off, int len) throws IOException {
139-
if (encoderLock != null) {
140-
encoderLock.lock();
136+
if (lock instanceof InternalLock locker) {
137+
locker.lock();
141138
try {
142139
lockedWrite(cbuf, off, len);
143140
} finally {
144-
encoderLock.unlock();
141+
locker.unlock();
145142
}
146143
} else {
147144
synchronized (super.lock) {
@@ -173,12 +170,12 @@ public void write(String str, int off, int len) throws IOException {
173170
public void write(CharBuffer cb) throws IOException {
174171
int position = cb.position();
175172
try {
176-
if (encoderLock != null) {
177-
encoderLock.lock();
173+
if (lock instanceof InternalLock locker) {
174+
locker.lock();
178175
try {
179176
lockedWrite(cb);
180177
} finally {
181-
encoderLock.unlock();
178+
locker.unlock();
182179
}
183180
} else {
184181
synchronized (super.lock) {
@@ -196,15 +193,15 @@ private void lockedWrite(CharBuffer cb) throws IOException {
196193
}
197194

198195
public void flush() throws IOException {
199-
if (encoderLock != null) {
200-
encoderLock.lock();
196+
if (lock instanceof InternalLock locker) {
197+
locker.lock();
201198
try {
202199
lockedFlush();
203200
} finally {
204-
encoderLock.unlock();
201+
locker.unlock();
205202
}
206203
} else {
207-
synchronized (super.lock) {
204+
synchronized (lock) {
208205
lockedFlush();
209206
}
210207
}
@@ -216,15 +213,15 @@ private void lockedFlush() throws IOException {
216213
}
217214

218215
public void close() throws IOException {
219-
if (encoderLock != null) {
220-
encoderLock.lock();
216+
if (lock instanceof InternalLock locker) {
217+
locker.lock();
221218
try {
222219
lockedClose();
223220
} finally {
224-
encoderLock.unlock();
221+
locker.unlock();
225222
}
226223
} else {
227-
synchronized (super.lock) {
224+
synchronized (lock) {
228225
lockedClose();
229226
}
230227
}
@@ -278,12 +275,6 @@ private StreamEncoder(OutputStream out, Object lock, CharsetEncoder enc) {
278275

279276
this.bb = ByteBuffer.allocate(INITIAL_BYTE_BUFFER_CAPACITY);
280277
this.maxBufferCapacity = MAX_BYTE_BUFFER_CAPACITY;
281-
282-
if (lock instanceof ReentrantLock) {
283-
this.encoderLock = (ReentrantLock) lock;
284-
} else {
285-
this.encoderLock = null;
286-
}
287278
}
288279

289280
private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {
@@ -299,8 +290,6 @@ private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {
299290
this.bb = ByteBuffer.allocate(INITIAL_BYTE_BUFFER_CAPACITY);
300291
this.maxBufferCapacity = MAX_BYTE_BUFFER_CAPACITY;
301292
}
302-
303-
this.encoderLock = new ReentrantLock();
304293
}
305294

306295
private void writeBytes() throws IOException {

0 commit comments

Comments
 (0)
Please sign in to comment.