segmentcache.java

来自「UCS (Ultra Corba Simulator) is one more 」· Java 代码 · 共 112 行

package com.corba.mnq.ui.text;

/*
 * @(#)SegmentCache.java        1.4 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

import java.util.ArrayList;
import java.util.List;

/**
 * SegmentCache caches <code>Segment</code>s to avoid continually
 * creating and destroying of <code>Segment</code>s. A common use
 * of this class would be:
 * 
 * <pre>
 *       Segment segment = segmentCache.getSegment();
 *       // do something with segment
 *       ...
 *       segmentCache.releaseSegment(segment);
 * </pre>
 * 
 * @version 1.4 01/23/03
 */
public class SegmentCache {

    /**
     * A global cache.
     */
    private static SegmentCache sharedCache = new SegmentCache();

    /**
     * A list of the currently unused Segments.
     */
    private List segments;

    /**
     * Returns the shared SegmentCache.
     */
    public static SegmentCache getSharedInstance() {
        return sharedCache;
    }

    /**
     * A convenience method to get a Segment from the shared
     * <code>SegmentCache</code>.
     */
    public static SegmentExt getSharedSegment() {
        return getSharedInstance().getSegment();
    }

    /**
     * A convenience method to release a Segment to the shared
     * <code>SegmentCache</code>.
     */
    public static void releaseSharedSegment(SegmentExt segment) {
        getSharedInstance().releaseSegment(segment);
    }

    /**
     * Creates and returns a SegmentCache.
     */
    public SegmentCache() {
        segments = new ArrayList(11);
    }

    /**
     * Returns a <code>Segment</code>. When done, the
     * <code>Segment</code> should be recycled by invoking
     * <code>releaseSegment</code>.
     */
    public SegmentExt getSegment() {
        synchronized (this) {
            int size = segments.size();

            if (size > 0) { return (SegmentExt) segments.remove(size - 1); }
        }
        return new CachedSegment();
    }

    /**
     * Releases a Segment. You should not use a Segment after you
     * release it, and you should NEVER release the same Segment more
     * than once, eg:
     * 
     * <pre>
     * segmentCache.releaseSegment(segment);
     * segmentCache.releaseSegment(segment);
     * </pre>
     * 
     * Will likely result in very bad things happening!
     */
    public void releaseSegment(SegmentExt segment) {
        if (segment instanceof CachedSegment) {
            synchronized (this) {
                segment.array = null;
                segment.count = 0;
                segments.add(segment);
            }
        }
    }

    /**
     * CachedSegment is used as a tagging interface to determine if a
     * Segment can successfully be shared.
     */
    private static class CachedSegment extends SegmentExt {
    }
}