Java

Java Concurrency

1. To directly control thread creation and management, simply instantiate Thread each time the application needs to initiate an asynchronous task.  An application that creates an instance of Thread must provide the code that will run in that thread. There are two ways to do this:
   
   Provide a Runnable object (this is the preferred way since the Runnable class doesn't need to extend Thread and so can extend any other needed class): The Runnable interface defines a single method, run, meant to contain the code executed in the thread. The Runnable object is passed to the Thread constructor:
   

   public class HelloRunnable implements Runnable {
       public void run() {
           System.out.println("Hello from a thread!");
       }
   
       public static void main(String args[]) {
           (new Thread(new HelloRunnable())).start();
       }
   }
   

   
   Subclass Thread: The Thread class itself implements Runnable, though its run method does nothing. An application can subclass Thread, providing its own implementation of run
   
   

   public class HelloThread extends Thread {
       public void run() {
           System.out.println("Hello from a thread!");
       }
   
       public static void main(String args[]) {
           (new HelloThread()).start();
       }
   }

2. To abstract thread management from the rest of your application, pass the application's tasks to an executor.

public class PrimeList implements Runnable {
  private ArrayList<BigInteger> primesFound;
  private int numPrimes, numDigits;

  public PrimeList(int numPrimes, int numDigits,
                   boolean runInBackground) {
    primesFound = new ArrayList<BigInteger>(numPrimes);
    this.numPrimes = numPrimes;
    this.numDigits = numDigits;
    if (runInBackground) {
      Thread t = new Thread(this);
      // Use low priority so you don't slow down server.
      thread.setPriority(Thread.MIN_PRIORITY);
      t.start();
    } else {
      run();
    }
  } 

try {
        Thread.sleep(4000);
    } catch (InterruptedException e) {
        // We've been interrupted: no more messages.
        return;
    }

        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }

public class StoppableTask extends Thread {
  private volatile boolean pleaseStop;
  public void run() {
    while (!pleaseStop) {
      // do some stuff...
    }
  }

  public void tellMeToStop() {
    pleaseStop = true;
  }
}

SynchronizedRGB color =

new SynchronizedRGB(0, 0, 0, "Pitch Black");
...
int myColorInt = color.getRGB();      //Statement 1
String myColorName = color.getName(); //Statement 2

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();

}

• Executor Interfaces
  
  
  The java.util.concurrent package defines three executor interfaces:
  

  • Executor: a simple interface that supports launching new tasks.
    If r is a Runnable object, and e is anExecutor object you can replace
    

    (new Thread(r)).start();
    

    with
    

    e.execute(r);

  • ExecutorService: a subinterface of Executor, which adds features that help manage the lifecycle, both of the individual tasks and of the executor itself.
    Supplements execute with a similar, but more versatile submit method. Like execute, submit accepts Runnable objects, but also accepts Callable objects, which allow the task to return a value.
  • ScheduledExecutorService: a subinterface of ExecutorService, supports future and/or periodic execution of task
• Thread Pools are the most common kind of executor implementation.
  Most of the executor implementations in java.util.concurrent use thread pools, which consist of worker threads
• Fork/Join is a framework (new in JDK 7) for taking advantage of multiple processors.