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

equal deleted inserted replaced

-:e89c7aaf2906
+:8595871a5446
 /*
-* Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2004, 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.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 /**
 * OutputStream that sends the output to the underlying stream using chunked
 * encoding as specified in RFC 2068.
 */
 private int preferredChunkDataSize;
 private int preferedHeaderSize;
 private int preferredChunkGrossSize;
 /* header for a complete Chunk */
 private byte[] completeHeader;
+private final Lock writeLock = new ReentrantLock();
 /* return the size of the header for a particular chunk size */
 private static int getHeaderSize(int size) {
 return (Integer.toHexString(size)).length() + CRLF_SIZE;
 }
 * chunk of preferredChunkSize size the data get stored as an incomplete
 * chunk of a following format: {space for data length}{CRLF}{data}
 * The size of the data is of course smaller than preferredChunkSize.
 */
 @Override
-public synchronized void write(byte b[], int off, int len) {
+public void write(byte b[], int off, int len) {
-ensureOpen();
+writeLock.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;
+throw new IndexOutOfBoundsException();
-}
+} else if (len == 0) {
+return;
-/* if b[] contains enough data then one loop cycle creates one complete
+}
-* data chunk with a header, body and a footer, and then flushes the
-* chunk to the underlying stream. Otherwise, the last loop cycle
+/* if b[] contains enough data then one loop cycle creates one complete
-* creates incomplete data chunk with empty header and with no footer
+* data chunk with a header, body and a footer, and then flushes the
-* and stores this incomplete chunk in an internal buffer buf[]
+* chunk to the underlying stream. Otherwise, the last loop cycle
-*/
+* creates incomplete data chunk with empty header and with no footer
-int bytesToWrite = len;
+* and stores this incomplete chunk in an internal buffer buf[]
-int inputIndex = off;  /* the index of the byte[] currently being written */
+*/
+int bytesToWrite = len;
-do {
+int inputIndex = off;  /* the index of the byte[] currently being written */
-/* enough data to complete a chunk */
-if (bytesToWrite >= spaceInCurrentChunk) {
+do {
+/* enough data to complete a chunk */
-/* header */
+if (bytesToWrite >= spaceInCurrentChunk) {
-for (int i=0; i<completeHeader.length; i++)
-buf[i] = completeHeader[i];
+/* header */
+for (int i = 0; i < completeHeader.length; i++)
-/* data */
+buf[i] = completeHeader[i];
-System.arraycopy(b, inputIndex, buf, count, spaceInCurrentChunk);
-inputIndex += spaceInCurrentChunk;
+/* data */
-bytesToWrite -= spaceInCurrentChunk;
+System.arraycopy(b, inputIndex, buf, count, spaceInCurrentChunk);
-count += spaceInCurrentChunk;
+inputIndex += spaceInCurrentChunk;
+bytesToWrite -= spaceInCurrentChunk;
-/* footer */
+count += spaceInCurrentChunk;
-buf[count++] = FOOTER[0];
-buf[count++] = FOOTER[1];
+/* footer */
-spaceInCurrentChunk = 0; //chunk is complete
+buf[count++] = FOOTER[0];
+buf[count++] = FOOTER[1];
-flush(false);
+spaceInCurrentChunk = 0; //chunk is complete
-if (checkError()){
-break;
+flush(false);
+if (checkError()) {
+break;
+}
 }
-}
+/* not enough data to build a chunk */
-/* not enough data to build a chunk */
+else {
-else {
+/* header */
-/* header */
+/* do not write header if not enough bytes to build a chunk yet */
-/* do not write header if not enough bytes to build a chunk yet */
+/* data */
-/* data */
+System.arraycopy(b, inputIndex, buf, count, bytesToWrite);
-System.arraycopy(b, inputIndex, buf, count, bytesToWrite);
+count += bytesToWrite;
-count += bytesToWrite;
+size += bytesToWrite;
-size += bytesToWrite;
+spaceInCurrentChunk -= bytesToWrite;
-spaceInCurrentChunk -= bytesToWrite;
+bytesToWrite = 0;
-bytesToWrite = 0;
+/* footer */
-/* footer */
+/* do not write header if not enough bytes to build a chunk yet */
-/* do not write header if not enough bytes to build a chunk yet */
+}
-}
+} while (bytesToWrite > 0);
-} while (bytesToWrite > 0);
+} finally {
-}
+writeLock.unlock();
+}
-@Override
+}
-public synchronized void write(int _b) {
-byte b[] = {(byte)_b};
+@Override
-write(b, 0, 1);
+public void write(int _b) {
-}
+writeLock.lock();
+try {
-public synchronized void reset() {
+byte b[] = {(byte) _b};
-count = preferedHeaderSize;
+write(b, 0, 1);
-size = 0;
+} finally {
-spaceInCurrentChunk = preferredChunkDataSize;
+writeLock.unlock();
+}
+}
+public void reset() {
+writeLock.lock();
+try {
+count = preferedHeaderSize;
+size = 0;
+spaceInCurrentChunk = preferredChunkDataSize;
+} finally {
+writeLock.unlock();
+}
 }
 public int size() {
 return size;
 }
 @Override
-public synchronized void close() {
+public void close() {
-ensureOpen();
+writeLock.lock();
+try {
-/* if we have buffer a chunked send it */
+ensureOpen();
-if (size > 0) {
+/* if we have buffer a chunked send it */
+if (size > 0) {
+flush(true);
+}
+/* send a zero length chunk */
 flush(true);
-}
+/* don't close the underlying stream */
-/* send a zero length chunk */
+out = null;
-flush(true);
+} finally {
+writeLock.unlock();
-/* don't close the underlying stream */
+}
-out = null;
+}
-}
+@Override
-@Override
+public void flush() {
-public synchronized void flush() {
+writeLock.lock();
-ensureOpen();
+try {
-if (size > 0) {
+ensureOpen();
-flush(true);
+if (size > 0) {
+flush(true);
+}
+} finally {
+writeLock.unlock();
 }
 }
 }

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