Where is the anonymous class in this? (lotsa code)

Question

When I compile ThreadPool.java, I get three classes: ThreadPool.class, ThreadPool$WorkerThread.class, and ThreadPool$1.class. I understand the first two, but I can't figure out where the anonymous class is coming from. Could it be some kind of automatically-generated wrapper class caused by the fact that all accesses to the Queue object are within synchronized blocks? Curiosity attacks!
Thanks,
Krum
ThreadPool.java:
package krum.util;
* A thread pool with a bounded task queue and fixed number of worker threads.
public class ThreadPool {
   protected Queue queue;
public ThreadPool(int threads, int taskQueueSize) {
   queue = new Queue(taskQueueSize);
   /* create the worker threads */
   for(int i = 0; i < threads; ++i) {
      Thread t = new Thread(new WorkerThread());
      t.setDaemon(true);
      t.start();
* Queues a task to be executed by this ThreadPool.  If the task queue is
* full, the task will run in the calling thread.  (Could easily be modified
* to throw an exception instead.)
public void doTask(Runnable task) {
   boolean added = false;
   synchronized(queue) {
      if(!queue.isFull()) {
         queue.add(task);
         added = true;
         queue.notify();
   if(!added) task.run();
* Tests if the task queue is empty.  Useful if you want to wait for all
* queued tasks to complete before terminating your program.
public boolean queueEmpty() {
   synchronized(queue) {
      return queue.isEmpty();
private class WorkerThread implements Runnable {
public void run() {
   Runnable task;
   while(true) {
      task = null;
      synchronized(queue) {
         try {
            if(queue.isEmpty()) queue.wait();
            else task = (Runnable)queue.getNext();
         } catch(InterruptedException e) { break; }
      if(task != null) task.run();
} /* end inner class WorkerThread */
} /* end class ThreadPool */Queue.java:
package krum.util;
* Implements a FIFO queue for storage and retrieval of objects.  This class
* is not synchronized.
public class Queue {
     /** circular buffer containing queued objects */
     protected Object[] queue;
     /** index of next object to be returned */
     protected int nextReturn;
     /** index in which to store next object inserted */
     protected int nextInsert;
public Queue(int capacity) {
     queue = new Object[capacity];
     nextInsert = 0;
     nextReturn = 0;
public boolean isEmpty() { return(queue[nextReturn] == null); }
public boolean isFull() { return(queue[nextInsert] != null); }
public void add(Object obj) throws QueueException {
     if(queue[nextInsert] == null) {
          queue[nextInsert] = obj;
          ++nextInsert;
          nextInsert %= queue.length;
     } else throw new QueueException();
public Object getNext() throws QueueException {
     if(queue[nextReturn] != null) {
          Object obj = queue[nextReturn];
          queue[nextReturn] = null;
          ++nextReturn;
          nextReturn %= queue.length;
          return obj;
     } else throw new QueueException();
} /* end class Queue */QueueException.java:
package krum.util;
public class QueueException extends RuntimeException { }

Answer 1

I can't explain why it happens, but I've seen this
behaviour before. I found that it was to do with an
inner class (WorkerThread in your code) having a
private constructor - if I made my inner class
constructor at least package (default) access, then
the anonymous class was no longer created.
The generated default constructor for a class has the
same access modifier as the class, so in your example,
the default constructor that the compiler generates is
private.
I suspect the problem will go away if you either:
1. Remove the private modifier from the WorkerThread
class declaration.
or:
2. Add a no-args constructor to the WorkerThread
class, and don't specify an access modifier.Yes, the reason is the private constructor. After decompile using JAD, the reason seems to be: if a private inner class does not explicitly have any constructor, a default no-arguments private constructor is created, and seems this default constructor can't be accessed directly (in source code, it can). So, another no-private constructor (package accessible) is created automatically (with an argument of Object's type), and the
new WorkThread();is actually like this:
new WorkThread(null);
private class WorkThread implements Runnable{
   private WorkThread(){}
   WorkThread(Object obj) {
      this();
}and I would guess it's using anonymous class tech to achieve this like:
new WorkThread(null) {
   WorkThread(Object obj){
      this();
}The JLS should have specified this situation.