infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-04-11 07:28:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

6882654: Remove dependency on java.util.concurrent from KeepAlive implementaion

Browse Source 
Reviewed-by: michaelm
This commit is contained in:
Chris Hegarty 2009-09-22 14:42:07 +01:00
parent 938ca04641
commit 147409ee76
3 changed files with 76 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
jdk/src/share/classes/sun/net/www/http/KeepAliveCache.java
View File

@ -25,12 +25,11 @@
package sun.net.www.http;
import java.io.InputStream;
import java.io.IOException;
import java.io.NotSerializableException;
import java.util.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;
/**
* A class that implements a cache of idle Http connections for keep-alive
@ -39,7 +38,7 @@ import java.util.concurrent.ConcurrentHashMap;
* @author Dave Brown
*/
public class KeepAliveCache
extends ConcurrentHashMap<KeepAliveKey, ClientVector>
extends HashMap<KeepAliveKey, ClientVector>
implements Runnable {
private static final long serialVersionUID = -2937172892064557949L;
@ -163,8 +162,8 @@ public class KeepAliveCache
* Errs on the side of caution (leave connections idle for a relatively
* short time).
*/
@Override
public void run() {
int total_cache;
do {
try {
Thread.sleep(LIFETIME);
@ -311,6 +310,7 @@ class KeepAliveKey {
/**
* Determine whether or not two objects of this type are equal
*/
@Override
public boolean equals(Object obj) {
if ((obj instanceof KeepAliveKey) == false)
return false;
@ -325,6 +325,7 @@ class KeepAliveKey {
* The hashCode() for this object is the string hashCode() of
* concatenation of the protocol, host name and port.
*/
@Override
public int hashCode() {
String str = protocol+host+port;
return this.obj == null? str.hashCode() :

83
jdk/src/share/classes/sun/net/www/http/KeepAliveStream.java
View File

@ -25,10 +25,7 @@
package sun.net.www.http;
import java.net.URL;
import java.net.HttpURLConnection;
import java.io.*;
import java.util.StringTokenizer;
import sun.net.ProgressSource;
import sun.net.www.MeteredStream;
@ -50,9 +47,8 @@ class KeepAliveStream extends MeteredStream implements Hurryable {
// has this KeepAliveStream been put on the queue for asynchronous cleanup.
protected boolean queuedForCleanup = false;
private static KeepAliveStreamCleaner queue = new KeepAliveStreamCleaner();
private static Thread cleanerThread = null;
private static boolean startCleanupThread;
private static final KeepAliveStreamCleaner queue = new KeepAliveStreamCleaner();
private static Thread cleanerThread; // null
/**
* Constructor
@ -155,43 +151,46 @@ class KeepAliveStream extends MeteredStream implements Hurryable {
}
}
private static synchronized void queueForCleanup(KeepAliveCleanerEntry kace) {
if(queue != null && !kace.getQueuedForCleanup()) {
if (!queue.offer(kace)) {
kace.getHttpClient().closeServer();
return;
}
kace.setQueuedForCleanup();
}
startCleanupThread = (cleanerThread == null);
if (!startCleanupThread) {
if (!cleanerThread.isAlive()) {
startCleanupThread = true;
}
}
if (startCleanupThread) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
// We want to create the Keep-Alive-SocketCleaner in the
// system threadgroup
ThreadGroup grp = Thread.currentThread().getThreadGroup();
ThreadGroup parent = null;
while ((parent = grp.getParent()) != null) {
grp = parent;
}
cleanerThread = new Thread(grp, queue, "Keep-Alive-SocketCleaner");
cleanerThread.setDaemon(true);
cleanerThread.setPriority(Thread.MAX_PRIORITY - 2);
cleanerThread.start();
return null;
private static void queueForCleanup(KeepAliveCleanerEntry kace) {
synchronized(queue) {
if(!kace.getQueuedForCleanup()) {
if (!queue.offer(kace)) {
kace.getHttpClient().closeServer();
return;
}
});
}
kace.setQueuedForCleanup();
queue.notifyAll();
}
boolean startCleanupThread = (cleanerThread == null);
if (!startCleanupThread) {
if (!cleanerThread.isAlive()) {
startCleanupThread = true;
}
}
if (startCleanupThread) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
// We want to create the Keep-Alive-SocketCleaner in the
// system threadgroup
ThreadGroup grp = Thread.currentThread().getThreadGroup();
ThreadGroup parent = null;
while ((parent = grp.getParent()) != null) {
grp = parent;
}
cleanerThread = new Thread(grp, queue, "Keep-Alive-SocketCleaner");
cleanerThread.setDaemon(true);
cleanerThread.setPriority(Thread.MAX_PRIORITY - 2);
cleanerThread.start();
return null;
}
});
}
} // queue
}
protected long remainingToRead() {

41
jdk/src/share/classes/sun/net/www/http/KeepAliveStreamCleaner.java
View File

@ -25,9 +25,8 @@
package sun.net.www.http;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.io.IOException;
import java.util.LinkedList;
import sun.net.NetProperties;
import java.security.AccessController;
import java.security.PrivilegedAction;
@ -44,7 +43,9 @@ import java.security.PrivilegedAction;
*/
@SuppressWarnings("serial") // never serialized
public class KeepAliveStreamCleaner extends LinkedBlockingQueue<KeepAliveCleanerEntry> implements Runnable
class KeepAliveStreamCleaner
extends LinkedList<KeepAliveCleanerEntry>
implements Runnable
{
// maximum amount of remaining data that we will try to cleanup
protected static int MAX_DATA_REMAINING = 512;
@ -78,23 +79,39 @@ public class KeepAliveStreamCleaner extends LinkedBlockingQueue<KeepAliveCleaner
}
public KeepAliveStreamCleaner()
{
super(MAX_CAPACITY);
}
public KeepAliveStreamCleaner(int capacity)
{
super(capacity);
@Override
public boolean offer(KeepAliveCleanerEntry e) {
if (size() >= MAX_CAPACITY)
return false;
return super.offer(e);
}
@Override
public void run()
{
KeepAliveCleanerEntry kace = null;
do {
try {
kace = poll((long)TIMEOUT, TimeUnit.MILLISECONDS);
synchronized(this) {
long before = System.currentTimeMillis();
long timeout = TIMEOUT;
while ((kace = poll()) == null) {
this.wait(timeout);
long after = System.currentTimeMillis();
long elapsed = after - before;
if (elapsed > timeout) {
/* one last try */
kace = poll();
break;
}
before = after;
timeout -= elapsed;
}
}
if(kace == null)
break;