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.base.jmod - Base Module
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module.
JDK 17 Base module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.base.jmod.
JDK 17 Base module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Base module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/internal/ref/CleanerImpl.java
/* * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package jdk.internal.ref; import java.lang.ref.Cleaner; import java.lang.ref.Cleaner.Cleanable; import java.lang.ref.ReferenceQueue; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Function; import jdk.internal.misc.InnocuousThread; /** * CleanerImpl manages a set of object references and corresponding cleaning actions. * CleanerImpl provides the functionality of {@link java.lang.ref.Cleaner}. */ public final class CleanerImpl implements Runnable { /** * An object to access the CleanerImpl from a Cleaner; set by Cleaner init. */ private static Function<Cleaner, CleanerImpl> cleanerImplAccess = null; /** * Heads of a CleanableList for each reference type. */ final PhantomCleanable<?> phantomCleanableList; // The ReferenceQueue of pending cleaning actions final ReferenceQueue<Object> queue; /** * Called by Cleaner static initialization to provide the function * to map from Cleaner to CleanerImpl. * @param access a function to map from Cleaner to CleanerImpl */ public static void setCleanerImplAccess(Function<Cleaner, CleanerImpl> access) { if (cleanerImplAccess == null) { cleanerImplAccess = access; } else { throw new InternalError("cleanerImplAccess"); } } /** * Called to get the CleanerImpl for a Cleaner. * @param cleaner the cleaner * @return the corresponding CleanerImpl */ static CleanerImpl getCleanerImpl(Cleaner cleaner) { return cleanerImplAccess.apply(cleaner); } /** * Constructor for CleanerImpl. */ public CleanerImpl() { queue = new ReferenceQueue<>(); phantomCleanableList = new PhantomCleanableRef(); } /** * Starts the Cleaner implementation. * Ensure this is the CleanerImpl for the Cleaner. * When started waits for Cleanables to be queued. * @param cleaner the cleaner * @param threadFactory the thread factory */ public void start(Cleaner cleaner, ThreadFactory threadFactory) { if (getCleanerImpl(cleaner) != this) { throw new AssertionError("wrong cleaner"); } // schedule a nop cleaning action for the cleaner, so the associated thread // will continue to run at least until the cleaner is reclaimable. new CleanerCleanable(cleaner); if (threadFactory == null) { threadFactory = CleanerImpl.InnocuousThreadFactory.factory(); } // now that there's at least one cleaning action, for the cleaner, // we can start the associated thread, which runs until // all cleaning actions have been run. Thread thread = threadFactory.newThread(this); thread.setDaemon(true); thread.start(); } /** * Process queued Cleanables as long as the cleanable lists are not empty. * A Cleanable is in one of the lists for each Object and for the Cleaner * itself. * Terminates when the Cleaner is no longer reachable and * has been cleaned and there are no more Cleanable instances * for which the object is reachable. * <p> * If the thread is a ManagedLocalsThread, the threadlocals * are erased before each cleanup */ @Override public void run() { Thread t = Thread.currentThread(); InnocuousThread mlThread = (t instanceof InnocuousThread) ? (InnocuousThread) t : null; while (!phantomCleanableList.isListEmpty()) { if (mlThread != null) { // Clear the thread locals mlThread.eraseThreadLocals(); } try { // Wait for a Ref, with a timeout to avoid getting hung // due to a race with clear/clean Cleanable ref = (Cleanable) queue.remove(60 * 1000L); if (ref != null) { ref.clean(); } } catch (Throwable e) { // ignore exceptions from the cleanup action // (including interruption of cleanup thread) } } } /** * Perform cleaning on an unreachable PhantomReference. */ public static final class PhantomCleanableRef extends PhantomCleanable<Object> { private final Runnable action; /** * Constructor for a phantom cleanable reference. * @param obj the object to monitor * @param cleaner the cleaner * @param action the action Runnable */ public PhantomCleanableRef(Object obj, Cleaner cleaner, Runnable action) { super(obj, cleaner); this.action = action; } /** * Constructor used only for root of phantom cleanable list. */ PhantomCleanableRef() { super(); this.action = null; } @Override protected void performCleanup() { action.run(); } /** * Prevent access to referent even when it is still alive. * * @throws UnsupportedOperationException always */ @Override public Object get() { throw new UnsupportedOperationException("get"); } /** * Direct clearing of the referent is not supported. * * @throws UnsupportedOperationException always */ @Override public void clear() { throw new UnsupportedOperationException("clear"); } } /** * A ThreadFactory for InnocuousThreads. * The factory is a singleton. */ static final class InnocuousThreadFactory implements ThreadFactory { static final ThreadFactory factory = new InnocuousThreadFactory(); static ThreadFactory factory() { return factory; } final AtomicInteger cleanerThreadNumber = new AtomicInteger(); public Thread newThread(Runnable r) { return InnocuousThread.newThread("Cleaner-" + cleanerThreadNumber.getAndIncrement(), r, Thread.MIN_PRIORITY - 2); } } /** * A PhantomCleanable implementation for tracking the Cleaner itself. */ static final class CleanerCleanable extends PhantomCleanable<Cleaner> { CleanerCleanable(Cleaner cleaner) { super(cleaner, cleaner); } @Override protected void performCleanup() { // no action } } }
⏎ jdk/internal/ref/CleanerImpl.java
Or download all of them as a single archive file:
File name: java.base-17.0.5-src.zip File size: 8883851 bytes Release date: 2022-09-13 Download
2023-09-26, 69008👍, 1💬
Popular Posts:
What Is commons-logging-1.2.jar? commons-logging-1.2.jar is the JAR file for Apache Commons Logging ...
What Is commons-codec-1.4.jar? commons-codec-1.4.jar is the JAR file for Apache Commons Codec 1.4, w...
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...
commons-collections4-4.2 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...
JDK 17 java.xml.jmod is the JMOD file for JDK 17 XML (eXtensible Markup Language) module. JDK 17 XML...