Swapper.java

package org.objectweb.jonas_ejb.container;

import java.util.LinkedList;
import java.util.NoSuchElementException;

import org.objectweb.util.monolog.api.BasicLevel;

class Swapper extends Thread {

    private JContainer container;

    private boolean valid;

    private boolean syncallbeans;

    private int memorylow;

    private LinkedList bfList = new LinkedList();

    private LinkedList bfsList = new LinkedList();

    private int swapTimeout = 5 * 60;

    private int memoryCount = 10;

    public Swapper(JContainer cont) {
        super("JonasSwapper");
        valid = true;
        syncallbeans = false;
        memorylow = 0;
        container = cont;
    }

    public void run() {

        while (valid) {
            BeanFactory bf = null;
            BeanFactory bfs = null;
            synchronized (this) {
                if (bfsList.size() == 0 && bfList.size() == 0) {
                    try {
                        wait(swapTimeout * 1000);
                    } catch (InterruptedException e) {
                        TraceEjb.logger.log(BasicLevel.ERROR, getName() + ": swapper interrupted");
                    } catch (Exception e) {
                        TraceEjb.logger.log(BasicLevel.ERROR, getName() + ": swapper exception", e);
                    }
                }
                try {
                    bf = (BeanFactory) bfList.removeFirst();
                } catch (NoSuchElementException e) {
                    bf = null;
                }
                try {
                    bfs = (BeanFactory) bfsList.removeFirst();
                } catch (NoSuchElementException e) {
                    bfs = null;
                }
            }
            // This can be done with lock off.
            if (bf != null) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, "swapper will try to reduce the cache");
                bf.reduceCache();
                continue;
            }
            if (bfs != null) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, "swapper will sync dirty instances");
                bfs.sync();
                continue;
            }
            // We were notified on timeout, probably to sync all beans.
            if (memorylow >= 10) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, "swapper will passivate all entity factories");
                container.syncAll(true);
                memorylow = 0;
            } else if (syncallbeans) {
                TraceEjb.swapper.log(BasicLevel.DEBUG, "swapper will sync all entity factories - " + memorylow);
                container.syncAll(false);
                memorylow++;
            }
        }
    }

    public synchronized void stopIt() {
        valid = false;
        notify();
    }

    public synchronized void addBeanFactorySync(BeanFactory bf) {
        if (!bfsList.contains(bf)) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, "" + bfsList.size());
            bfsList.addLast(bf);
            notify();
        }
    }

    public synchronized void addBeanFactory(BeanFactory bf) {
        if (!bfList.contains(bf)) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, "" + bfList.size());
            bfList.addLast(bf);
            // don't notify because it's better to wait that instances are released
            // before reducing the pool.
            // This is called typically when the pool is empty!
        }
    }

    public synchronized void setSwapperTimeout(int t) {
        TraceEjb.swapper.log(BasicLevel.DEBUG, "" + t);
        syncallbeans = true;
        if (t < swapTimeout) {
            swapTimeout = t;
        }
        notify();
    }

    public int getSwapperTimeout() {
        if (syncallbeans) {
            return swapTimeout;
        } else {
            return 0;
        }
    }
}

---