JDK 11 java.rmi.jmod - RMI Module
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module.
JDK 11 RMI module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.rmi.jmod.
JDK 11 RMI module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 RMI module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.rmi.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ sun/rmi/transport/ObjectTable.java
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package sun.rmi.transport;
import java.lang.ref.ReferenceQueue;
import java.rmi.NoSuchObjectException;
import java.rmi.Remote;
import java.rmi.dgc.VMID;
import java.rmi.server.ExportException;
import java.rmi.server.ObjID;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Map;
import sun.rmi.runtime.Log;
import sun.rmi.runtime.NewThreadAction;
/**
* Object table shared by all implementors of the Transport interface.
* This table maps object ids to remote object targets in this address
* space.
*
* @author Ann Wollrath
* @author Peter Jones
*/
public final class ObjectTable {
/** maximum interval between complete garbage collections of local heap */
private final static long gcInterval = // default 1 hour
AccessController.doPrivileged((PrivilegedAction<Long>) () ->
Long.getLong("sun.rmi.dgc.server.gcInterval", 3600000));
/**
* lock guarding objTable and implTable.
* Holders MAY acquire a Target instance's lock or keepAliveLock.
*/
private static final Object tableLock = new Object();
/** tables mapping to Target, keyed from ObjectEndpoint and impl object */
private static final Map<ObjectEndpoint,Target> objTable =
new HashMap<>();
private static final Map<WeakRef,Target> implTable =
new HashMap<>();
/**
* lock guarding keepAliveCount, reaper, and gcLatencyRequest.
* Holders may NOT acquire a Target instance's lock or tableLock.
*/
private static final Object keepAliveLock = new Object();
/** count of non-permanent objects in table or still processing calls */
private static int keepAliveCount = 0;
/** thread to collect unreferenced objects from table */
private static Thread reaper = null;
/** queue notified when weak refs in the table are cleared */
static final ReferenceQueue<Object> reapQueue = new ReferenceQueue<>();
/** handle for GC latency request (for future cancellation) */
private static GC.LatencyRequest gcLatencyRequest = null;
/*
* Disallow anyone from creating one of these.
*/
private ObjectTable() {}
/**
* Returns the target associated with the object id.
*/
static Target getTarget(ObjectEndpoint oe) {
synchronized (tableLock) {
return objTable.get(oe);
}
}
/**
* Returns the target associated with the remote object
*/
public static Target getTarget(Remote impl) {
synchronized (tableLock) {
return implTable.get(new WeakRef(impl));
}
}
/**
* Returns the stub for the remote object <b>obj</b> passed
* as a parameter. This operation is only valid <i>after</i>
* the object has been exported.
*
* @return the stub for the remote object, <b>obj</b>.
* @exception NoSuchObjectException if the stub for the
* remote object could not be found.
*/
public static Remote getStub(Remote impl)
throws NoSuchObjectException
{
Target target = getTarget(impl);
if (target == null) {
throw new NoSuchObjectException("object not exported");
} else {
return target.getStub();
}
}
/**
* Remove the remote object, obj, from the RMI runtime. If
* successful, the object can no longer accept incoming RMI calls.
* If the force parameter is true, the object is forcibly unexported
* even if there are pending calls to the remote object or the
* remote object still has calls in progress. If the force
* parameter is false, the object is only unexported if there are
* no pending or in progress calls to the object.
*
* @param obj the remote object to be unexported
* @param force if true, unexports the object even if there are
* pending or in-progress calls; if false, only unexports the object
* if there are no pending or in-progress calls
* @return true if operation is successful, false otherwise
* @exception NoSuchObjectException if the remote object is not
* currently exported
*/
public static boolean unexportObject(Remote obj, boolean force)
throws java.rmi.NoSuchObjectException
{
synchronized (tableLock) {
Target target = getTarget(obj);
if (target == null) {
throw new NoSuchObjectException("object not exported");
} else {
if (target.unexport(force)) {
removeTarget(target);
return true;
} else {
return false;
}
}
}
}
/**
* Add target to object table. If it is not a permanent entry, then
* make sure that reaper thread is running to remove collected entries
* and keep VM alive.
*/
static void putTarget(Target target) throws ExportException {
ObjectEndpoint oe = target.getObjectEndpoint();
WeakRef weakImpl = target.getWeakImpl();
if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
DGCImpl.dgcLog.log(Log.VERBOSE, "add object " + oe);
}
synchronized (tableLock) {
/**
* Do nothing if impl has already been collected (see 6597112). Check while
* holding tableLock to ensure that Reaper cannot process weakImpl in between
* null check and put/increment effects.
*/
if (target.getImpl() != null) {
if (objTable.containsKey(oe)) {
throw new ExportException(
"internal error: ObjID already in use");
} else if (implTable.containsKey(weakImpl)) {
throw new ExportException("object already exported");
}
objTable.put(oe, target);
implTable.put(weakImpl, target);
if (!target.isPermanent()) {
incrementKeepAliveCount();
}
}
}
}
/**
* Remove target from object table.
*
* NOTE: This method must only be invoked while synchronized on
* the "tableLock" object, because it does not do so itself.
*/
private static void removeTarget(Target target) {
// assert Thread.holdsLock(tableLock);
ObjectEndpoint oe = target.getObjectEndpoint();
WeakRef weakImpl = target.getWeakImpl();
if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
DGCImpl.dgcLog.log(Log.VERBOSE, "remove object " + oe);
}
objTable.remove(oe);
implTable.remove(weakImpl);
target.markRemoved(); // handles decrementing keep-alive count
}
/**
* Process client VM signalling reference for given ObjID: forward to
* corresponding Target entry. If ObjID is not found in table,
* no action is taken.
*/
static void referenced(ObjID id, long sequenceNum, VMID vmid) {
synchronized (tableLock) {
ObjectEndpoint oe =
new ObjectEndpoint(id, Transport.currentTransport());
Target target = objTable.get(oe);
if (target != null) {
target.referenced(sequenceNum, vmid);
}
}
}
/**
* Process client VM dropping reference for given ObjID: forward to
* corresponding Target entry. If ObjID is not found in table,
* no action is taken.
*/
static void unreferenced(ObjID id, long sequenceNum, VMID vmid,
boolean strong)
{
synchronized (tableLock) {
ObjectEndpoint oe =
new ObjectEndpoint(id, Transport.currentTransport());
Target target = objTable.get(oe);
if (target != null)
target.unreferenced(sequenceNum, vmid, strong);
}
}
/**
* Increments the "keep-alive count".
*
* The "keep-alive count" is the number of non-permanent remote objects
* that are either in the object table or still have calls in progress.
* Therefore, this method should be invoked exactly once for every
* non-permanent remote object exported (a remote object must be
* exported before it can have any calls in progress).
*
* The VM is "kept alive" while the keep-alive count is greater than
* zero; this is accomplished by keeping a non-daemon thread running.
*
* Because non-permanent objects are those that can be garbage
* collected while exported, and thus those for which the "reaper"
* thread operates, the reaper thread also serves as the non-daemon
* VM keep-alive thread; a new reaper thread is created if necessary.
*/
static void incrementKeepAliveCount() {
synchronized (keepAliveLock) {
keepAliveCount++;
if (reaper == null) {
reaper = AccessController.doPrivileged(
new NewThreadAction(new Reaper(), "Reaper", false));
reaper.start();
}
/*
* While there are non-"permanent" objects in the object table,
* request a maximum latency for inspecting the entire heap
* from the local garbage collector, to place an upper bound
* on the time to discover remote objects that have become
* unreachable (and thus can be removed from the table).
*/
if (gcLatencyRequest == null) {
gcLatencyRequest = GC.requestLatency(gcInterval);
}
}
}
/**
* Decrements the "keep-alive count".
*
* The "keep-alive count" is the number of non-permanent remote objects
* that are either in the object table or still have calls in progress.
* Therefore, this method should be invoked exactly once for every
* previously-exported non-permanent remote object that both has been
* removed from the object table and has no calls still in progress.
*
* If the keep-alive count is decremented to zero, then the current
* reaper thread is terminated to cease keeping the VM alive (and
* because there are no more non-permanent remote objects to reap).
*/
static void decrementKeepAliveCount() {
synchronized (keepAliveLock) {
keepAliveCount--;
if (keepAliveCount == 0) {
if (!(reaper != null)) { throw new AssertionError(); }
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
reaper.interrupt();
return null;
}
});
reaper = null;
/*
* If there are no longer any non-permanent objects in the
* object table, we are no longer concerned with the latency
* of local garbage collection here.
*/
gcLatencyRequest.cancel();
gcLatencyRequest = null;
}
}
}
/**
* The Reaper thread waits for notifications that weak references in the
* object table have been cleared. When it receives a notification, it
* removes the corresponding entry from the table.
*
* Since the Reaper is created as a non-daemon thread, it also serves
* to keep the VM from exiting while there are objects in the table
* (other than permanent entries that should neither be reaped nor
* keep the VM alive).
*/
private static class Reaper implements Runnable {
public void run() {
try {
do {
// wait for next cleared weak reference
WeakRef weakImpl = (WeakRef) reapQueue.remove();
synchronized (tableLock) {
Target target = implTable.get(weakImpl);
if (target != null) {
if (!target.isEmpty()) {
throw new Error(
"object with known references collected");
} else if (target.isPermanent()) {
throw new Error("permanent object collected");
}
removeTarget(target);
}
}
} while (!Thread.interrupted());
} catch (InterruptedException e) {
// pass away if interrupted
}
}
}
}
⏎ sun/rmi/transport/ObjectTable.java
Or download all of them as a single archive file:
File name: java.rmi-11.0.1-src.zip File size: 275032 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.scripting.jmod - Scripting Module
2023-10-10, 37461👍, 1💬
Related Topics: