In the Spotlight - Shay Banon

// similar to j.u.c.Executors.newFixedThreadPool(int nThreads)
new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>())

// similar to j.u.c.Executors.newCachedThreadPool()
new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

// similar to j.u.c.Executors.newCachedThreadPool()
new ThreadPoolExecutor(coreThreads, maximumThreads,
                                      60L, TimeUnit.SECONDS,
                                      new LinkedBlockingQueue<Runnable>());

public class ScalingQueue<E> extends LinkedBlockingQueue<E> {
 
    /**
     * The executor this Queue belongs to
     */
    private ThreadPoolExecutor executor;
 
    /**
     * Creates a <tt>TaskQueue</tt> with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public ScalingQueue() {
        super();
    }
 
    /**
     * Creates a <tt>TaskQueue</tt> with the given (fixed) capacity.
     *
     * @param capacity the capacity of this queue.
     */
    public ScalingQueue(int capacity) {
        super(capacity);
    }
 
    /**
     * Sets the executor this queue belongs to.
     */
    public void setThreadPoolExecutor(ThreadPoolExecutor executor) {
        this.executor = executor;
    }
 
    /**
     * Inserts the specified element at the tail of this queue if there is at
     * least one available thread to run the current task. If all pool threads
     * are actively busy, it rejects the offer.
     *
     * @param o the element to add.
     * @return <tt>true</tt> if it was possible to add the element to this
     *         queue, else <tt>false</tt>
     * @see ThreadPoolExecutor#execute(Runnable)
     */
    @Override
    public boolean offer(E o) {
        int allWorkingThreads = executor.getActiveCount() + super.size();
        return allWorkingThreads < executor.getPoolSize() && super.offer(o);
    }
}

public class ForceQueuePolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        try {
            executor.getQueue().put(r);
        } catch (InterruptedException e) {
            //should never happen since we never wait
            throw new RejectedExecutionException(e);
        }
    }
}

public class ScalingThreadPoolExecutor extends ThreadPoolExecutor {
 
    /**
     * number of threads that are actively executing tasks
     */
    private final AtomicInteger activeCount = new AtomicInteger();
 
    public ScalingThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                                     long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
 
    @Override
    public int getActiveCount() {
        return activeCount.get();
    }
 
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        activeCount.incrementAndGet();
    }
 
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        activeCount.decrementAndGet();
    }
}

public static ExecutorService newScalingThreadPool(int min, int max,
                                                   long keepAliveTime) {
    ScalingQueue<Runnable> queue = new ScalingQueue<Runnable>();
    ThreadPoolExecutor executor = new ScalingThreadPoolExecutor(min, max, keepAliveTime, TimeUnit.MILLISECONDS, queue);
    executor.setRejectedExecutionHandler(new ForceQueuePolicy());
    queue.setThreadPoolExecutor(executor);
    return executor;
}

{
    compass : {
        engine : {
            connection : "test-index"
        },
 
        event : {
            preCreate : {
                event1 : {
                    type : "test.MyEvent1"
                },
                "event2.type" : "test.MyEvent2"
            }
        }
    }
}

{
    "compass-core-mapping" : {
        package : "org.compass.core.test.simple",
        class : {
            name : "A",
            alias : "A",
            id : {
                name : "id"
            },
            property : [
                {
                    name : "value",
                    "meta-data" : {
                        name : "value"
                    }
                },
                {
                    name : "otherValue",
                    "meta-data" : {
                        name : "other-value"
                    }
                }
            ]
        }
    }
}

{
    "compass-core-mapping" : {
        "root-json-object" : [
            {
                alias : "test",
                id : {
                    name : "id"
                },
                property : [
                    {
                        name : "int",
                        "value-converter" : "int",
                        format : "0000"
                    },
                    {
                        name : "float",
                        "value-converter" : "float",
                        format : "0000.00",
                        store : "compress"
                    }],
                content : {
                    name : "content"
                }
            }
     }
}