tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Costin Manolache <cmanola...@yahoo.com>
Subject Re: DO NOT REPLY [Bug 16001] - Tag.release() not invoked
Date Sat, 18 Jan 2003 20:10:50 GMT
Bill Barker wrote:

> If tag-pooling works for you, I'm happy for you.  The current
> implementation
> doesn't work for me big time.  However, I'm very interested in Costin's
> claim that it can be done thread-local.

One quick question ( looking at generated code ) - why is the TP limited
to 5 instances ? If you expect 20+ concurent requests ( where the TP 
would actually matter ) - you'll have the overhead of TP sync, and almost 
no benefit. Can you try again with a larger capacity ?

Regarding the "claim" that it can be done thread-local: I attached a first
draft, I'll enhance it later ( it could use ThreadWithAttributes - to save
one extra hashtable lookup ). Let me know if it helps.


Costin

package org.apache.jasper.runtime;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import org.apache.jasper.Constants;
import java.util.Hashtable;
import java.util.Enumeration;

/**
 * Pool of tag handlers that can be reused.
 * Experimental: use thread local.
 *
 * @author Jan Luehe
 */
public class TagHandlerPool {

    private int maxSize=100;
    private int initialSize=5;
    private ThreadLocal perThread=new ThreadLocal();
    // for cleanup
    private Hashtable threadData=new Hashtable();

    private static class PerThreadData {
        Tag handlers[];
        int current;
    }

    /**
     * Constructs a tag handler pool with the default capacity.
     */
    public TagHandlerPool() {
        this(Constants.MAX_POOL_SIZE);
    }

    /**
     * Constructs a tag handler pool with the given capacity.
     *
     * @param capacity Tag handler pool capacity
     */
    public TagHandlerPool(int capacity) {
        this.maxSize = capacity;
        //this.handlers = new Tag[capacity];
        //this.current = -1;
    }

    /**
     * Gets the next available tag handler from this tag handler pool,
     * instantiating one if this tag handler pool is empty.
     *
     * @param handlerClass Tag handler class
     *
     * @return Reused or newly instantiated tag handler
     *
     * @throws JspException if a tag handler cannot be instantiated
     */
    public Tag get(Class handlerClass) throws JspException {
        PerThreadData ptd=(PerThreadData)perThread.get();
        if( ptd!=null && ptd.current >=0 ) {
            return ptd.handlers[ptd.current--];
        } else {
            try {
                return (Tag) handlerClass.newInstance();
            } catch (Exception e) {
                throw new JspException(e.getMessage(), e);
            }
        }
    }

    /**
     * Adds the given tag handler to this tag handler pool, unless this tag
     * handler pool has already reached its capacity, in which case the tag
     * handler's release() method is called.
     *
     * @param handler Tag handler to add to this tag handler pool
     */
    public void reuse(Tag handler) {
        PerThreadData ptd=(PerThreadData)perThread.get();

        if( ptd==null ) {
            ptd=new PerThreadData();
            ptd.handlers=new Tag[ initialSize ];
            ptd.current=0;
            threadData.put( ptd, ptd );
        }

        if (ptd.current < (ptd.handlers.length - 1)) {
            ptd.handlers[++ptd.current] = handler;
            return;
        }

        // no more space
        if( ptd.handlers.length < maxSize ) {
            // reallocate
            Tag newH[]=new Tag[ptd.handlers.length + initialSize];
            System.arraycopy(ptd.handlers, 0, newH, 0, ptd.handlers.length);
            ptd.handlers=newH;
            ptd.handlers[++ptd.current]=handler;
            return;
        }

        //else
        handler.release();
    }

    /**
     * Calls the release() method of all available tag handlers in this tag
     * handler pool.
     */
    public synchronized void release() {
        Enumeration ptdE=threadData.keys();
        while( ptdE.hasMoreElements() ) {
            PerThreadData ptd=(PerThreadData)ptdE.nextElement();
            for (int i=ptd.current; i>=0; i--) {
                ptd.handlers[i].release();
            }
        }
    }
}



--
To unsubscribe, e-mail:   <mailto:tomcat-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:tomcat-dev-help@jakarta.apache.org>


Mime
View raw message