processes vs. threads

processes

• everything happing in a computer is a process
• time slicing
  distribution of time allocated to all processes running concurrently
• top: Linux console command listing all active processes

threads

• every process has at least one thread executing
• multi-threaded execution
  within one process (program), execution is carried out
  asynchronously (independently) by several threads
• the process (program) continues as long as there is
  at least one thread still running

parallelization

• distribution of computing load onto several (many)
  CPUs (central processing unit) or GPUs (graphics processing unit)
• message passing interface (MPI)
  standardized message-passing system
  for parallelization (Fortran, C++, ...)
• Java 7 Fork and Join framework
  $\rightarrow$ advanced numerical computing

sleeping

• main() is called by an a priori Thread
• System.currentTimeMillis() returns the current time

import java.util.*;

public class SleepingDemo {
  public static void main(String args[])
        throws InterruptedException             // needed when working with threads
  {
  long startTime = System.currentTimeMillis();  // current time in milli seconds
  for (int i = 0; i< 5; i++) 
    {
    Thread.sleep(2000);                         // pause current thread for 2 seconds
    System.out.printf("time since start: %5d ms\n",
                      System.currentTimeMillis()-startTime);
    }
  }  // end of  main()
}    // end of SleepingDemo

runnable classes

• an instantiated class implementing runnable
  can have its own thread
• any runnable class needs to habe a member function .run()
  • .run() is executed when the thread is started
  • the thread stops when reaching the end of .run()
  • as for the .main() method
• one can interrrupt a thread or
  join a thread (waiting for the thread to die)

threads and interrupts

• an interrupt is a notification, not a termination signal
• threads stop at the end of .run()
• Java is platform independent, use the code
  to test the performace of various CPUs

import java.util.*;

public class ThreadDemo {
  public static void main(String args[])
        throws InterruptedException           // needed when working with threads
  {
  long startTime = System.currentTimeMillis();

  SomeOperations some = new SomeOperations(); // class instantiation
  Thread t = new Thread(some);                // create new thread
  t.start();                                  // start some.run()

  for (int i = 0; i < 6; i++) 
    {
    Thread.sleep(2000);                       // pause thread of main()
    System.out.printf("   time since start: %5d ms\n",
            System.currentTimeMillis()-startTime);
    System.out.printf("nOperations/1000000: %5d\n",
                  some.nOperations/1000000);

    if (i==3)                               // thread would run ad infinitum
      t.interrupt();                        // if not interupted
    }
    
  }  // end of ThreadDemo.main()
}    // end of class ThreadDemo

// *** **************
// *** runnable class
// *** **************

class SomeOperations implements Runnable {
  double number = 1.0;
  public long nOperations = 0;

  public void run()              // every runnable class needs 
  {                              // this member function
  long temp;
  while (!Thread.interrupted())  // infinite loop!
    {
    nOperations++;
    number = number * (1.0+1.0/nOperations);
    }
  System.out.printf("\n %s \n\n","I have been interrupted, stopping now");
  }  // end of SomeOperations.run()
}    // end of class SomeOperations

exercise: threads

large number of threads on a single processor

Write a program generating a large number of threads and measuring the resulting computational performance.

• the runnable class does some simple caculations if not interrupted
• instantiate $N=1,\,\dots,\, 1000$ copies of the runnable class and start their threads
• measure the overal performace, the total number of computations performed, as a function of the number of threads $\ N$

the Java virtual maschine (JVM)

platform independent computing

• a component of the Java runtime environment (JRE)
• executes platform-independent bytecodes (.class files)
• a JIT (just in time) compiler translates the bytecode
  into the native machine code (operating system calls)
• other components of the JRE are
  
  • heap memory (memory allocated for the program)
  • garbage collection
  • ...

garbage collection (GC)

• automatic memory management
• reclaiming memory occupied by objects no longer used
• automatic GC in Java, no memory leaks
• (partly) manual in C, C++