org.eclipse.persistence.internal.identitymaps.HardCacheWeakIdentityMap Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.persistence.core Show documentation
EclipseLink build based upon Git transaction ecdf3c32c4
There is a newer version: 4.0.2
Show newest version
/*
 * Copyright (c) 1998, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.internal.identitymaps;

import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.helper.linkedlist.*;
import org.eclipse.persistence.internal.sessions.AbstractSession;

/**
 * Purpose: A HardCacheWeakIdentityMap is identical to the weak identity map, however the weak reference
 * can be a performance problem for some types of apps because it can cause too much garbage collection
 * of objects read causing them to be re-read and re-built (this defeats the purpose of the cache).
 * The hard weak cache solves this by also holding a fixed number of objects in memory to improve caching.

 * This class makes use of an exposed node linked list to maintain the objects by storing the link nodes in the cache key.
 * 
Responsibilities:

 *  Guarantees identity
 * 
 Allows garbage collection
 * 
 Increases performance by maintaining a fixed size cache of LRU objects when memory is available
 * 
 The default size of the reference cache is half the max size
 * 
 * @since TOPLink/Java 1.2
 */
public class HardCacheWeakIdentityMap extends WeakIdentityMap {
    /** A subset of cache entries have hard references maintained in this list to reduce garbage collection frequency */
    protected ExposedNodeLinkedList referenceCache;

    public HardCacheWeakIdentityMap(int size, ClassDescriptor descriptor, AbstractSession session, boolean isIsolated) {
        super(size, descriptor, session, isIsolated);
        this.referenceCache = new ExposedNodeLinkedList();
    }

    /**
     * Use a ReferenceCacheKey that also stores the linked list node to manage
     * the LRU sub-cache of references.
     */
    @Override
    public CacheKey createCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        return new ReferenceCacheKey(primaryKey, object, writeLockValue, readTime, isIsolated);
    }

    /**
     * Return the linked reference cache.
     */
    public ExposedNodeLinkedList getReferenceCache() {
        return referenceCache;
    }

    /**
     * Allows subclass to create a SoftReference to the object.
     * @param object is the domain object to cache.
     */
    public Object buildReference(Object object) {
        return object;
    }

    /**
     * Checks if the object is null, or reference's object is null.
     * @param the object for hard or the reference for soft.
     */
    public boolean hasReference(Object reference) {
        return reference != null;
    }

    /**
     * Remove the cache key from the map and the sub-cache list.
     */
    public Object remove(CacheKey cacheKey) {
        if (cacheKey == null) {
            return null;
        }
        LinkedNode node = ((ReferenceCacheKey)cacheKey).getReferenceCacheNode();
        // Node is initially null while object is being built.
        if (node != null) {
            synchronized (this.referenceCache) {
                this.referenceCache.remove(node);
            }
        }
        return super.remove(cacheKey);
    }

    /**
     * Store the object in the cache at its primary key, and add to sub-cache list.
     */
    @Override
    public CacheKey put(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        CacheKey cacheKey = super.put(primaryKey, object, writeLockValue, readTime);
        cacheKey.updateAccess();
        return cacheKey;
    }

    /**
     * This method will be used to update the max cache size.
     */
    public synchronized void updateMaxSize(int maxSize) {
        setMaxSize(maxSize);
        synchronized (this.referenceCache) {
            // Remove the LRU items if max size exceeded.
            while (this.referenceCache.size() > this.maxSize) {
                this.referenceCache.removeLast();
            }
        }
    }

    /**
     * Inner class to define the specialized weak cache key.
     * Keeps track of the linked list node to allow quick repositioning.
     */
    public class ReferenceCacheKey extends WeakCacheKey {
        protected LinkedNode referenceNode;

        public ReferenceCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime, boolean isIsolated) {
            super(primaryKey, object, writeLockValue, readTime, isIsolated);
        }

        public LinkedNode getReferenceCacheNode() {
            return referenceNode;
        }

        public void setReferenceCacheNode(LinkedNode referenceNode) {
            this.referenceNode = referenceNode;
        }

        public ExposedNodeLinkedList getReferenceCache() {
            return referenceCache;
        }

        /**
         * Notifies that cache key that it has been accessed.
         * Allows the LRU sub-cache to be maintained,
         * the cache node must be moved to the front of the list.
         */
        public void updateAccess() {
            // Check if the node's contents is null (was removed),
            // or ref value may have garbage collected so reset it.
            if ((this.referenceNode != null) && (!hasReference(this.referenceNode.getContents()))) {
                this.referenceNode.setContents(buildReference(getObject()));
            }
            // PERF: Synchronize on the linked list.
            synchronized (referenceCache) {
                // If reference node is null, add to start (new cache key).
                if (this.referenceNode == null) {
                    this.referenceNode = referenceCache.addFirst(buildReference(getObject()));
                } else {
                    // This is a fast constant time operations because of the linked list usage.
                    referenceCache.moveFirst(getReferenceCacheNode());
                }
                // Remove the old LRU items if max size exceeded (if was removed).
                while (referenceCache.size() > maxSize) {
                    referenceCache.removeLast();
                }
            }
        }
    }
}