Thread Pools in Google App Engine

/* 
 * Start all threads in the constructor
 * or a separate start() method. 
 */

Queue<Callable> queue = new LinkedList<> ();

public void submit (Callable work) {
    synchronized (queue) {
        queue.add (work);
        queue.notify ();
    }
}

public void work () {
    while (true) {
        Callable work = null;
        
        synchronized (queue) {
            // Wait for work to be available
            while (queue.isEmpty ()) {
                queue.wait ();
            }
            
            // Get work unit
            work = queue.poll ();
        }
        
        // Execute
        work.call ();
    }
}

Queue<Callable> queue = new LinkedList<> ();
AtomicInteger activeThreads = new AtomicInteger (0);
final int maxThreads = 50;

protected void startNewThread () {
    // Start a new thread
}
        
public void submit (Callable work) {
    synchronized (queue) {
        queue.add (work);
        if (activeThreads.get () < maxThreads) {
            activeThreads.incrementAndGet ();
            startNewThread ();
        }
    }
}

public void work () {
    while (true) {
        Callable work = null;
        
        synchronized (queue) {
            // Get work unit
            work = queue.poll ();
            
            // Exit if the queue is empty
            if (work == null) {
                activeThreads.decrementAndGet ();
                return;
            }
        }
        
        // Execute
        work.call ();
    }
}

@Override
    public void service (
        HttpServletRequest req, 
        HttpServletResponse resp) 
        throws ServletException, 
            IOException {
    ThreadFactoryImpl.beginRequestThread ();
    try {
        super.service (req, resp);
    } finally {
        ThreadFactoryImpl.endRequestThread ();
    }
}

private static final ThreadLocal<Thread> requestThread = 
    new ThreadLocal<> ();

public static beginRequestThread () {
    requestThread.set (Thread.currentThread ());
}

private static final ThreadLocal<Thread> requestThread = 
    new ThreadLocal<> ();

protected void startNewThread () {
    final Thread requestThreadForCallingThread = 
        requestThread.get ();
        
    Thread workerThread = new Thread () {
        public void run () {
            requestThread.set (requestThreadForCallingThread);
            
            // ... do work
        }
    };
    workerThread.start ();
}

private static ThreadLocal<ThreadPool> threadPool = 
    new ThreadLocal<> ();
    
private static Map<Thread,ThreadPool> threadPools = 
    new WeakHashMap<> ();

public static ThreadPool getThreadPool () {
    ThreadPool tp = threadPool.get ();
    if (tp != null) {
        return tp;
    }
    
    /*
     * Need to set up a thread pool for this thread
     *
     * This can all be done in a ThreadLocal.initialValue 
     * but I'll write it out here because it is much 
     * clearer.
     */
    
    // Figure out which thread
    // is our request thread
    Thread requestThread = requestThread.get ();
    synchronized (threadPools) {
        tp = threadPools.get (requestThread);
        
        if (tp != null) {
            // Ok, we have a thread pool for 
            // this request thread. Save it.
            threadPool.set (tp);
            return tp;
        }
        
        // No thread pool for this request
        // thread. Set up a new one.
        tp = new ThreadPoolImpl ();
        
        // Put it in the big map of all 
        // thread pools
        threadPools.put (requestThread, tp);
        
        // Put it in the thread local for quick 
        // access
        threadPool.set (tp);
        
        // Return it
        return tp;
    }
}

protected static class TestRunnable 
    implements Runnable {
    
    /** 
     * Nanos when the runnable was submitted
     * to the ThreadManager.
     */
    public long submittedAt;
    
    /**
     * Nanos from submittedAt to start of 
     * run() method.
      */
    public long timeToStart;
    
    /**
     * Flag to signal completion.
     */
    private boolean done = false;
    
    /** 
     * Used to synchronize the benchmark 
     */
    private final Semaphore semaphore;
    
    public TestRunnable (Semaphore semaphore) {
        this.semaphore = semaphore;
    }
    
    public synchronized void preSubmit () {
         submittedAt = System.nanoTime ();
    }
    
    public void run () {
        // Mark when we entered the run() method
        final long startedAt = System.nanoTime ();
        
        // Fill in the result and signal 
        // completion
        synchronized (this) {
            timeToStart = startedAt - submittedAt;
            
            // Set the done flag and notify
            // waiters on exit
            done = true;
            notifyAll ();
            
            // Notify the benchmark that a 
            // slot is available.
            semaphore.release ();
        }
    }
    
    public synchronized void await () throws Exception {
        while (!done) {
            wait ();
        }
    }
}

protected String threadManagerBenchmark () throws Exception {
    List<TestRunnable> runnables = new ArrayList<> ();
    
    // App Engine limit is 50 concurrent per-request threads
    // so set this to a little bit lower.
    Semaphore semaphore = new Semaphore (40, true);
    for (int i = 0; i < 160; ++i) {
        // Set up the runnable
        TestRunnable testRunnable = new TestRunnable (semaphore);
        runnables.add (testRunnable);
        
        // Wait for a slot to become available
        semaphore.acquire ();
        
        // Mark this as the time of submission
        testRunnable.preSubmit ();
        
        // Start it
        ThreadManager.createThreadForCurrentRequest (testRunnable).start ();
    }
    
    // Gather up the results
    StringBuilder sb = new StringBuilder ();
    for (TestRunnable testRunnable : runnables) {
        // Wait for the runnable to complete
        testRunnable.await ();
        sb.append ("," + testRunnable.timeToStart);
    }
    return sb.toString ();
}