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

equal deleted inserted replaced

-:e89c7aaf2906
+:8595871a5446
 /*
-* Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1994, 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
 import java.io.*;
 import java.net.*;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Properties;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 import sun.net.NetworkClient;
 import sun.net.ProgressSource;
 import sun.net.www.MessageHeader;
 import sun.net.www.HeaderParser;
 import sun.net.www.MeteredStream;
 /**
 * @author Herb Jellinek
 * @author Dave Brown
 */
 public class HttpClient extends NetworkClient {
+protected final ReentrantLock clientLock = new ReentrantLock();
 // whether this httpclient comes from the cache
 protected boolean cachedHttpClient = false;
 protected boolean inCache;
 if (ret != null) {
 String ak = httpuc == null ? AuthenticatorKeys.DEFAULT
 : httpuc.getAuthenticatorKey();
 boolean compatible = Objects.equals(ret.proxy, p)
 && Objects.equals(ret.getAuthenticatorKey(), ak);
+final Lock lock = ret.clientLock;
 if (compatible) {
-synchronized (ret) {
+lock.lock();
+try {
 ret.cachedHttpClient = true;
 assert ret.inCache;
 ret.inCache = false;
 if (httpuc != null && ret.needsTunneling())
 httpuc.setTunnelState(TUNNELING);
 logFinest("KeepAlive stream retrieved from the cache, " + ret);
+} finally {
+lock.unlock();
 }
 } else {
 // We cannot return this connection to the cache as it's
 // KeepAliveTimeout will get reset. We simply close the connection.
 // This should be fine as it is very rare that a connection
 // to the same host will not use the same proxy.
-synchronized(ret) {
+lock.lock();
+try  {
 ret.inCache = false;
 ret.closeServer();
+} finally {
+lock.unlock();
 }
 ret = null;
 }
 }
 }
 } else {
 closeServer();
 }
 }
-protected synchronized boolean available() {
+protected boolean available() {
 boolean available = true;
 int old = -1;
+clientLock.lock();
 try {
 try {
 old = serverSocket.getSoTimeout();
 serverSocket.setSoTimeout(1);
 BufferedInputStream tmpbuf =
 }
 } catch (IOException e) {
 logFinest("HttpClient.available(): " +
 "SocketException: not available");
 available = false;
+} finally {
+clientLock.unlock();
 }
 return available;
 }
-protected synchronized void putInKeepAliveCache() {
+protected void putInKeepAliveCache() {
-if (inCache) {
+clientLock.lock();
-assert false : "Duplicate put to keep alive cache";
+try {
-return;
+if (inCache) {
-}
+assert false : "Duplicate put to keep alive cache";
-inCache = true;
+return;
-kac.put(url, null, this);
+}
-}
+inCache = true;
+kac.put(url, null, this);
-protected synchronized boolean isInKeepAliveCache() {
+} finally {
-return inCache;
+clientLock.unlock();
+}
+}
+protected boolean isInKeepAliveCache() {
+clientLock.lock();
+try {
+return inCache;
+} finally {
+clientLock.unlock();
+}
 }
 /*
 * Close an idle connection to this URL (if it exists in the
 * cache).
 }
 /*
 * Returns true if this httpclient is from cache
 */
-public synchronized boolean isCachedConnection() {
+public boolean isCachedConnection() {
-return cachedHttpClient;
+clientLock.lock();
+try {
+return cachedHttpClient;
+} finally {
+clientLock.unlock();
+}
 }
 /*
 * Finish any work left after the socket connection is
 * established.  In the normal http case, it's a NO-OP. Subclass
 }
 /*
 * call openServer in a privileged block
 */
-private synchronized void privilegedOpenServer(final InetSocketAddress server)
+private void privilegedOpenServer(final InetSocketAddress server)
 throws IOException
 {
+assert clientLock.isHeldByCurrentThread();
 try {
 java.security.AccessController.doPrivileged(
 new java.security.PrivilegedExceptionAction<>() {
 public Void run() throws IOException {
 openServer(server.getHostString(), server.getPort());
 super.openServer(proxyHost, proxyPort);
 }
 /*
 */
-protected synchronized void openServer() throws IOException {
+protected void openServer() throws IOException {
 SecurityManager security = System.getSecurityManager();
-if (security != null) {
+clientLock.lock();
-security.checkConnect(host, port);
+try {
-}
+if (security != null) {
+security.checkConnect(host, port);
-if (keepingAlive) { // already opened
+}
-return;
-}
+if (keepingAlive) { // already opened
-if (url.getProtocol().equals("http") ||
-url.getProtocol().equals("https") ) {
-if ((proxy != null) && (proxy.type() == Proxy.Type.HTTP)) {
-sun.net.www.URLConnection.setProxiedHost(host);
-privilegedOpenServer((InetSocketAddress) proxy.address());
-usingProxy = true;
 return;
+}
+if (url.getProtocol().equals("http") ||
+url.getProtocol().equals("https")) {
+if ((proxy != null) && (proxy.type() == Proxy.Type.HTTP)) {
+sun.net.www.URLConnection.setProxiedHost(host);
+privilegedOpenServer((InetSocketAddress) proxy.address());
+usingProxy = true;
+return;
+} else {
+// make direct connection
+openServer(host, port);
+usingProxy = false;
+return;
+}
 } else {
-// make direct connection
+/* we're opening some other kind of url, most likely an
-openServer(host, port);
+* ftp url.
-usingProxy = false;
+*/
-return;
+if ((proxy != null) && (proxy.type() == Proxy.Type.HTTP)) {
-}
+sun.net.www.URLConnection.setProxiedHost(host);
+privilegedOpenServer((InetSocketAddress) proxy.address());
-} else {
+usingProxy = true;
-/* we're opening some other kind of url, most likely an
+return;
-* ftp url.
+} else {
-*/
+// make direct connection
-if ((proxy != null) && (proxy.type() == Proxy.Type.HTTP)) {
+super.openServer(host, port);
-sun.net.www.URLConnection.setProxiedHost(host);
+usingProxy = false;
-privilegedOpenServer((InetSocketAddress) proxy.address());
+return;
-usingProxy = true;
+}
-return;
+}
-} else {
+} finally {
-// make direct connection
+clientLock.unlock();
-super.openServer(host, port);
-usingProxy = false;
-return;
-}
 }
 }
 public String getURLFile() throws IOException {
 }
 return ret;
 }
-public synchronized InputStream getInputStream() {
+public InputStream getInputStream() {
-return serverInput;
+clientLock.lock();
+try {
+return serverInput;
+} finally {
+clientLock.unlock();
+}
 }
 public OutputStream getOutputStream() {
 return serverOutput;
 }

branch	JDK-8229867-branch
changeset 57968	8595871a5446
parent 53563	a4b7ea85d668