Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ sun/net/www/http/KeepAliveCache.java
/* * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ 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.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) * @author Dave Brown */ public class KeepAliveCache extends HashMap<KeepAliveKey, ClientVector> implements Runnable { private static final long serialVersionUID = -2937172892064557949L; /* maximum # keep-alive connections to maintain at once * This should be 2 by the HTTP spec, but because we don't support pipe-lining * a larger value is more appropriate. So we now set a default of 5, and the value * refers to the number of idle connections per destination (in the cache) only. * It can be reset by setting system property "http.maxConnections". */ static final int MAX_CONNECTIONS = 5; static int result = -1; static int getMaxConnections() { if (result == -1) { result = AccessController.doPrivileged( new GetIntegerAction("http.maxConnections", MAX_CONNECTIONS)) .intValue(); if (result <= 0) { result = MAX_CONNECTIONS; } } return result; } static final int LIFETIME = 5000; private Thread keepAliveTimer = null; /** * Constructor */ public KeepAliveCache() {} /** * Register this URL and HttpClient (that supports keep-alive) with the cache * @param url The URL contains info about the host and port * @param http The HttpClient to be cached */ public synchronized void put(final URL url, Object obj, HttpClient http) { boolean startThread = (keepAliveTimer == null); if (!startThread) { if (!keepAliveTimer.isAlive()) { startThread = true; } } if (startThread) { clear(); /* Unfortunately, we can't always believe the keep-alive timeout we got * back from the server. If I'm connected through a Netscape proxy * 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; AccessController.doPrivileged(new PrivilegedAction<>() { public Void run() { keepAliveTimer = InnocuousThread.newSystemThread("Keep-Alive-Timer", cache); keepAliveTimer.setDaemon(true); keepAliveTimer.setPriority(Thread.MAX_PRIORITY - 2); keepAliveTimer.start(); return null; } }); } KeepAliveKey key = new KeepAliveKey(url, obj); ClientVector v = super.get(key); if (v == null) { int keepAliveTimeout = http.getKeepAliveTimeout(); v = new ClientVector(keepAliveTimeout > 0 ? 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) { KeepAliveKey key = new KeepAliveKey(h.url, obj); ClientVector v = super.get(key); if (v != null) { v.remove(h); if (v.isEmpty()) { removeVector(key); } } } /* called by a clientVector thread when all its connections have timed out * and that vector of connections should be removed. */ synchronized void removeVector(KeepAliveKey k) { super.remove(k); } /** * 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; } return v.get(); } /* Sleeps for an alloted timeout, then checks for timed out connections. * Errs on the side of caution (leave connections idle for a relatively * short time). */ @Override public void run() { do { try { Thread.sleep(LIFETIME); } catch (InterruptedException e) {} // Remove all outdated HttpClients. synchronized (this) { long currentTime = System.currentTimeMillis(); List<KeepAliveKey> keysToRemove = new ArrayList<>(); for (KeepAliveKey key : keySet()) { ClientVector v = get(key); synchronized (v) { KeepAliveEntry e = v.peek(); while (e != null) { if ((currentTime - e.idleStartTime) > v.nap) { v.poll(); e.hc.closeServer(); } else { break; } e = v.peek(); } if (v.isEmpty()) { keysToRemove.add(key); } } } for (KeepAliveKey key : keysToRemove) { removeVector(key); } } } while (!isEmpty()); } /* * Do not serialize this class! */ private void writeObject(ObjectOutputStream stream) throws IOException { throw new NotSerializableException(); } private void readObject(ObjectInputStream stream) 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> { private static final long serialVersionUID = -8680532108106489459L; // sleep time in milliseconds, before cache clear int nap; ClientVector(int nap) { this.nap = nap; } synchronized HttpClient get() { if (isEmpty()) { return null; } // Loop until we find a connection that has not timed out HttpClient hc = null; long currentTime = System.currentTimeMillis(); do { KeepAliveEntry e = pop(); if ((currentTime - e.idleStartTime) > nap) { e.hc.closeServer(); } else { hc = e.hc; } } while ((hc == null) && (!isEmpty())); return hc; } /* return a still valid, unused HttpClient */ synchronized void put(HttpClient h) { if (size() >= KeepAliveCache.getMaxConnections()) { h.closeServer(); // otherwise the connection remains in limbo } 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(ObjectOutputStream stream) throws IOException { throw new NotSerializableException(); } private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { throw new NotSerializableException(); } } class KeepAliveKey { private String protocol = null; private String host = null; private int port = 0; private Object obj = null; // additional key, such as socketfactory /** * Constructor * * @param url the URL containing the protocol, host and port information */ public KeepAliveKey(URL url, Object obj) { this.protocol = url.getProtocol(); this.host = url.getHost(); this.port = url.getPort(); this.obj = obj; } /** * Determine whether or not two objects of this type are equal */ @Override public boolean equals(Object obj) { if ((obj instanceof KeepAliveKey) == false) return false; KeepAliveKey kae = (KeepAliveKey)obj; return host.equals(kae.host) && (port == kae.port) && protocol.equals(kae.protocol) && this.obj == kae.obj; } /** * 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() : str.hashCode() + this.obj.hashCode(); } } class KeepAliveEntry { HttpClient hc; long idleStartTime; KeepAliveEntry(HttpClient hc, long idleStartTime) { this.hc = hc; this.idleStartTime = idleStartTime; } }
⏎ sun/net/www/http/KeepAliveCache.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 206307👍, 0💬
Popular Posts:
jlGui is a music player for the Java platform. It is based on Java Sound 1.0 (i.e. JDK 1.3+). It sup...
Where to find answers to frequently asked questions on Download and Installing of Older Versions? He...
Apache Commons Lang 3 is the 3rd version of Apache Commons Lang, which provides a host of helper uti...
What Is junit-3.8.1.jar? junit-3.8.1.jar is the version 3.8.1 of JUnit JAR library file. JUnit is a ...
commons-collections4-4.2 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...