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 17 java.rmi.jmod - RMI Module
JDK 17 java.rmi.jmod is the JMOD file for JDK 17 RMI (Remote Method Invocation) module.
JDK 17 RMI module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.rmi.jmod.
JDK 17 RMI module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 RMI module source code files are stored in \fyicenter\jdk-17.0.5\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, 2021, 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 */ @SuppressWarnings("removal") 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. */ @SuppressWarnings("removal") 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). */ @SuppressWarnings("removal") 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-17.0.5-src.zip File size: 220001 bytes Release date: 2022-09-13 Download
⇒ JDK 17 java.scripting.jmod - Scripting Module
2023-11-06, 10040👍, 0💬
Popular Posts:
What Is jtds-1.2.2.jar? jtds-1.2.2.jar is the JAR files of jTDS Java library 1.2.2, which is a JDBC ...
How to download and install ojdbc11.jar for Oracle 21c? ojdbc11.jar for Oracle 21c is a Java JDBC Dr...
Apache BCEL Source Code Files are inside the Apache BCEL source package file like bcel-6.5.0-src.zip...
How to read XML document with DTD validation from socket connections with the socket\DelayedInput.ja.. .
commons-collections4-4.2 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...