Help with understanding multi-threaded code

Question

Hi Everyone,
I am currently reading a book on multi-threading and up until recently I have been able to understand what is going on. The thing is the complexity of the code has just jumped up about two gears without warning. The code is now using inner classes which I am trying to develop an understanding of but I am not finding it easy going, and the book has been lite on explanations. If anybody can help with the following code it will be really appreciated.
public class SetPriority extends Object
     private static Runnable makeRunnable()
          Runnable r = new Runnable()
               public void run()
                    for(int i=0; i<5; i++)
                         Thread t = Thread.currentThread();
                         System.out.println("in run() - priority=" + t.getPriority() +
                                      ", name=" + t.getName());
                         try{
                              Thread.sleep(2000);
                         }catch(InterruptedException x){
                              //ignore
          return r;
     public static void main(String[] args)
          Thread threadA = new Thread(makeRunnable(), "threadA");
          threadA.setPriority(8);
          threadA.start();
          Thread threadB = new Thread(makeRunnable(), "threadB");
          threadB.setPriority(2);
          threadB.start();
          Runnable r = new Runnable()
               public void run()
                    Thread threadC = new Thread(makeRunnable(), "threadC");
                    threadC.start();
          Thread threadD = new Thread(r, "threadD");
          threadD.setPriority(7);
          threadD.start();
          try{
               Thread.sleep(3000);
          }catch(InterruptedException x){
               //ignore
          threadA.setPriority(3);
          System.out.println("in main() - threadA.getPriority()=" + threadA.getPriority());
}My greatest challenge is understanding how the makeRunnable() method works. I don't understand how this inner class can be declared static and then multiple "instances" created from it. I know that I have no idea what is going on, please help!!!
Thanks for your time.
Regards
Davo
P.S.: If you know of any really good references on inner classes, particularly URL resources, please let me know. Thanks again.

Answer 1

Yikes!! The good news is that you're unlikely to see such convoluted code in real life. But here we go.
"private static Runnable makeRunnable()" declares a method that returns objects of type Runnable. The fact that the method is declared "static" is pretty irrelevant - I'll describe what that means later.
The body of the method creates and returns an object of type Runnable. Not much special about it, except that you can give such an object to the constructor of class Thread and as a result the run() method of this Runnable object will be called on a new thread of execution (think - in parallel).
Now the way it creates this Runnable object is by using the "anonymous inner class" syntax. In effect the method is doing the same as
public class MyNewClass implements Runnable {
    public void run() {
        // All the same code inside run()
public class SetPriority {
    private static Runnable makeRunnable() {
        Runnable r = new MyNewClass();
        return r;
    // The rest of the original code
}Except you don't bother declaring MyNewClass. You're not interested in defining any new method signatures. You just want to create an object that implements Runnable and has certain instructions that you want inside the run() method. Think of the whole approach as shorthand.
Think about this for a while. In the mean time I'll write up the "static".