jdk-sandbox: comparison src/java.base/share/classes/sun/net/www/http/ChunkedInputStream.java

equal deleted inserted replaced

-:e89c7aaf2906
+:8595871a5446
 /*
-* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2019, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * questions.
 */
 package sun.net.www.http;
 import java.io.*;
-import java.util.*;
+import java.util.concurrent.locks.ReentrantLock;
-import sun.net.*;
 import sun.net.www.*;
 /**
 * A <code>ChunkedInputStream</code> provides a stream for reading a body of
 * a http message that can be sent as a series of chunks, each with its own
 * <p>
 * A <code>ChunkedInputStream</code> is also <code>Hurryable</code> so it
 * can be hurried to the end of the stream if the bytes are available on
 * the underlying stream.
 */
-public
+public class ChunkedInputStream extends InputStream implements Hurryable {
-class ChunkedInputStream extends InputStream implements Hurryable {
 /**
 * The underlying stream
 */
 private InputStream in;
 * Indicates if the chunked stream has been closed using the
 * <code>close</code> method.
 */
 private boolean closed;
+final ReentrantLock readLock = new ReentrantLock();
 /*
 * Maximum chunk header size of 2KB + 2 bytes for CRLF
 */
 private static final int MAX_CHUNK_HEADER_SIZE = 2050;
 /**
 * State to indicate that next field should be :-
 *  chunk-size [ chunk-extension ] CRLF
 */
 * @return     the next byte of data, or <code>-1</code> if the end of the
 *             stream is reached.
 * @exception  IOException  if an I/O error occurs.
 * @see        java.io.FilterInputStream#in
 */
-public synchronized int read() throws IOException {
+public int read() throws IOException {
-ensureOpen();
+readLock.lock();
-if (chunkPos >= chunkCount) {
+try {
-if (readAhead(true) <= 0) {
+ensureOpen();
-return -1;
+if (chunkPos >= chunkCount) {
-}
+if (readAhead(true) <= 0) {
-}
+return -1;
-return chunkData[chunkPos++] & 0xff;
+}
+}
+return chunkData[chunkPos++] & 0xff;
+} finally {
+readLock.unlock();
+}
 }
 /**
 * Reads bytes from this stream into the specified byte array, starting at
 * @param      len   maximum number of bytes to read.
 * @return     the number of bytes read, or <code>-1</code> if the end of
 *             the stream has been reached.
 * @exception  IOException  if an I/O error occurs.
 */
-public synchronized int read(byte b[], int off, int len)
+public int read(byte b[], int off, int len)
 throws IOException
 {
-ensureOpen();
+readLock.lock();
-if ((off < 0) || (off > b.length) || (len < 0) ||
+try {
-((off + len) > b.length) || ((off + len) < 0)) {
+ensureOpen();
-throw new IndexOutOfBoundsException();
+if ((off < 0) || (off > b.length) || (len < 0) ||
-} else if (len == 0) {
+((off + len) > b.length) || ((off + len) < 0)) {
-return 0;
+throw new IndexOutOfBoundsException();
-}
+} else if (len == 0) {
+return 0;
-int avail = chunkCount - chunkPos;
+}
-if (avail <= 0) {
-/*
+int avail = chunkCount - chunkPos;
-* Optimization: if we're in the middle of the chunk read
+if (avail <= 0) {
-* directly from the underlying stream into the caller's
+/*
-* buffer
+* Optimization: if we're in the middle of the chunk read
-*/
+* directly from the underlying stream into the caller's
-if (state == STATE_READING_CHUNK) {
+* buffer
-return fastRead( b, off, len );
+*/
-}
+if (state == STATE_READING_CHUNK) {
+return fastRead(b, off, len);
-/*
+}
-* We're not in the middle of a chunk so we must read ahead
-* until there is some chunk data available.
+/*
-*/
+* We're not in the middle of a chunk so we must read ahead
-avail = readAhead(true);
+* until there is some chunk data available.
-if (avail < 0) {
+*/
-return -1;      /* EOF */
+avail = readAhead(true);
-}
+if (avail < 0) {
-}
+return -1;      /* EOF */
-int cnt = (avail < len) ? avail : len;
+}
-System.arraycopy(chunkData, chunkPos, b, off, cnt);
+}
-chunkPos += cnt;
+int cnt = (avail < len) ? avail : len;
+System.arraycopy(chunkData, chunkPos, b, off, cnt);
-return cnt;
+chunkPos += cnt;
+return cnt;
+} finally {
+readLock.unlock();
+}
 }
 /**
 * Returns the number of bytes that can be read from this input
 * stream without blocking.
 * @return     the number of bytes that can be read from this input
 *             stream without blocking.
 * @exception  IOException  if an I/O error occurs.
 * @see        java.io.FilterInputStream#in
 */
-public synchronized int available() throws IOException {
+public int available() throws IOException {
-ensureOpen();
+readLock.lock();
+try {
-int avail = chunkCount - chunkPos;
+ensureOpen();
-if(avail > 0) {
-return avail;
+int avail = chunkCount - chunkPos;
-}
+if (avail > 0) {
+return avail;
-avail = readAhead(false);
+}
-if (avail < 0) {
+avail = readAhead(false);
-return 0;
-} else  {
+if (avail < 0) {
-return avail;
+return 0;
+} else {
+return avail;
+}
+} finally {
+readLock.unlock();
 }
 }
 /**
 * Close the stream by either returning the connection to the
 * possible (without blocking) then the connection can be
 * returned to the keep alive cache.
 *
 * @exception  IOException  if an I/O error occurs.
 */
-public synchronized void close() throws IOException {
+public void close() throws IOException {
-if (closed) {
+if (closed) return;
-return;
+readLock.lock();
-}
+try {
-closeUnderlying();
+if (closed) {
-closed = true;
+return;
+}
+closeUnderlying();
+closed = true;
+} finally {
+readLock.unlock();
+}
 }
 /**
 * Hurry the input stream by reading everything from the underlying
 * stream. If the last chunk (and optional trailers) can be read without
 * <p>
 * Note that if an error has occurred or we can't get to last chunk
 * without blocking then this stream can't be hurried and should be
 * closed.
 */
-public synchronized boolean hurry() {
+public boolean hurry() {
-if (in == null || error) {
+readLock.lock();
-return false;
-}
 try {
-readAhead(false);
+if (in == null || error) {
-} catch (Exception e) {
+return false;
-return false;
+}
-}
+try {
-if (error) {
+readAhead(false);
-return false;
+} catch (Exception e) {
-}
+return false;
+}
-return (state == STATE_DONE);
+if (error) {
+return false;
+}
+return (state == STATE_DONE);
+} finally {
+readLock.unlock();
+}
 }
 }

branch	JDK-8229867-branch
changeset 57968	8595871a5446
parent 47216	71c04702a3d5