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

equal deleted inserted replaced

-:31c9cf5eca62
+:74e1913a98c0
 /*
-* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1996, 2017, 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
 package sun.net.www.http;
 import java.io.IOException;
 import java.io.NotSerializableException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.net.URL;
+import java.util.List;
 import jdk.internal.misc.InnocuousThread;
+import sun.security.action.GetIntegerAction;
 /**
 * A class that implements a cache of idle Http connections for keep-alive
 *
 * @author Stephen R. Pietrowicz (NCSA)
 */
 static final int MAX_CONNECTIONS = 5;
 static int result = -1;
 static int getMaxConnections() {
 if (result == -1) {
-result = java.security.AccessController.doPrivileged(
+result = AccessController.doPrivileged(
-new sun.security.action.GetIntegerAction("http.maxConnections",
+new GetIntegerAction("http.maxConnections", MAX_CONNECTIONS))
-MAX_CONNECTIONS))
 .intValue();
-if (result <= 0)
+if (result <= 0) {
 result = MAX_CONNECTIONS;
 }
-return result;
+}
+return result;
 }
 static final int LIFETIME = 5000;
 private Thread keepAliveTimer = null;
 * to a server that sent me a keep-alive
 * time of 15 sec, the proxy unilaterally terminates my connection
 * The robustness to get around this is in HttpClient.parseHTTP()
 */
 final KeepAliveCache cache = this;
-java.security.AccessController.doPrivileged(
+AccessController.doPrivileged(new PrivilegedAction<>() {
-new java.security.PrivilegedAction<>() {
 public Void run() {
 keepAliveTimer = InnocuousThread.newSystemThread("Keep-Alive-Timer", cache);
 keepAliveTimer.setDaemon(true);
 keepAliveTimer.setPriority(Thread.MAX_PRIORITY - 2);
 keepAliveTimer.start();
 KeepAliveKey key = new KeepAliveKey(url, obj);
 ClientVector v = super.get(key);
 if (v == null) {
 int keepAliveTimeout = http.getKeepAliveTimeout();
-v = new ClientVector(keepAliveTimeout > 0?
+v = new ClientVector(keepAliveTimeout > 0 ?
-keepAliveTimeout*1000 : LIFETIME);
+keepAliveTimeout * 1000 : LIFETIME);
 v.put(http);
 super.put(key, v);
 } else {
 v.put(http);
 }
 }
 /* remove an obsolete HttpClient from its VectorCache */
-public synchronized void remove (HttpClient h, Object obj) {
+public synchronized void remove(HttpClient h, Object obj) {
 KeepAliveKey key = new KeepAliveKey(h.url, obj);
 ClientVector v = super.get(key);
 if (v != null) {
 v.remove(h);
-if (v.empty()) {
+if (v.isEmpty()) {
 removeVector(key);
 }
 }
 }
 /**
 * Check to see if this URL has a cached HttpClient
 */
 public synchronized HttpClient get(URL url, Object obj) {
 KeepAliveKey key = new KeepAliveKey(url, obj);
 ClientVector v = super.get(key);
 if (v == null) { // nothing in cache yet
 return null;
 }
 public void run() {
 do {
 try {
 Thread.sleep(LIFETIME);
 } catch (InterruptedException e) {}
+// Remove all outdated HttpClients.
 synchronized (this) {
-/* Remove all unused HttpClients.  Starting from the
-* bottom of the stack (the least-recently used first).
-* REMIND: It'd be nice to not remove *all* connections
-* that aren't presently in use.  One could have been added
-* a second ago that's still perfectly valid, and we're
-* needlessly axing it.  But it's not clear how to do this
-* cleanly, and doing it right may be more trouble than it's
-* worth.
-*/
 long currentTime = System.currentTimeMillis();
+List<KeepAliveKey> keysToRemove = new ArrayList<>();
-ArrayList<KeepAliveKey> keysToRemove
-= new ArrayList<>();
 for (KeepAliveKey key : keySet()) {
 ClientVector v = get(key);
 synchronized (v) {
-int i;
+KeepAliveEntry e = v.peek();
+while (e != null) {
-for (i = 0; i < v.size(); i++) {
-KeepAliveEntry e = v.elementAt(i);
 if ((currentTime - e.idleStartTime) > v.nap) {
-HttpClient h = e.hc;
+v.poll();
-h.closeServer();
+e.hc.closeServer();
 } else {
 break;
 }
+e = v.peek();
 }
-v.subList(0, i).clear();
+if (v.isEmpty()) {
-if (v.size() == 0) {
 keysToRemove.add(key);
 }
 }
 }
 for (KeepAliveKey key : keysToRemove) {
 removeVector(key);
 }
 }
-} while (size() > 0);
+} while (!isEmpty());
-return;
 }
 /*
 * Do not serialize this class!
 */
-private void writeObject(java.io.ObjectOutputStream stream)
+private void writeObject(ObjectOutputStream stream) throws IOException {
-throws IOException {
 throw new NotSerializableException();
 }
-private void readObject(java.io.ObjectInputStream stream)
+private void readObject(ObjectInputStream stream)
-throws IOException, ClassNotFoundException {
+throws IOException, ClassNotFoundException
+{
 throw new NotSerializableException();
 }
 }
 /* FILO order for recycling HttpClients, should run in a thread
 * to time them out.  If > maxConns are in use, block.
 */
+class ClientVector extends ArrayDeque<KeepAliveEntry> {
-class ClientVector extends java.util.Stack<KeepAliveEntry> {
 private static final long serialVersionUID = -8680532108106489459L;
 // sleep time in milliseconds, before cache clear
 int nap;
+ClientVector(int nap) {
-ClientVector (int nap) {
 this.nap = nap;
 }
 synchronized HttpClient get() {
-if (empty()) {
+if (isEmpty()) {
 return null;
-} else {
+}
-// Loop until we find a connection that has not timed out
-HttpClient hc = null;
+// Loop until we find a connection that has not timed out
-long currentTime = System.currentTimeMillis();
+HttpClient hc = null;
-do {
+long currentTime = System.currentTimeMillis();
-KeepAliveEntry e = pop();
+do {
-if ((currentTime - e.idleStartTime) > nap) {
+KeepAliveEntry e = pop();
-e.hc.closeServer();
+if ((currentTime - e.idleStartTime) > nap) {
-} else {
+e.hc.closeServer();
-hc = e.hc;
+} else {
-}
+hc = e.hc;
-} while ((hc== null) && (!empty()));
+}
-return hc;
+} while ((hc == null) && (!isEmpty()));
-}
+return hc;
 }
 /* return a still valid, unused HttpClient */
 synchronized void put(HttpClient h) {
 if (size() >= KeepAliveCache.getMaxConnections()) {
 } else {
 push(new KeepAliveEntry(h, System.currentTimeMillis()));
 }
 }
+/* remove an HttpClient */
+synchronized boolean remove(HttpClient h) {
+for (KeepAliveEntry curr : this) {
+if (curr.hc == h) {
+return super.remove(curr);
+}
+}
+return false;
+}
 /*
 * Do not serialize this class!
 */
-private void writeObject(java.io.ObjectOutputStream stream)
+private void writeObject(ObjectOutputStream stream) throws IOException {
-throws IOException {
 throw new NotSerializableException();
 }
-private void readObject(java.io.ObjectInputStream stream)
+private void readObject(ObjectInputStream stream)
-throws IOException, ClassNotFoundException {
+throws IOException, ClassNotFoundException
+{
 throw new NotSerializableException();
 }
 }
 class KeepAliveKey {
 private String      protocol = null;
 private String      host = null;
 private int         port = 0;

changeset 47361	74e1913a98c0
parent 47216	71c04702a3d5
child 57956	e0b8b019d2f5