JAVA-BASED REAL-TIME PROGRAMMING

3.1.1 Thread creation
At start of a Java Virtual Machine (JVM), the so called main thread starts
executing the Java program by calling the main method of the class given to
the JVM. In case of an applet, the same applies but then the main method is
part of the host application, which in turn calls the applet’s init method. To
have another thread running, a system call has to be done (within the JVM
or to the OS, at this stage we don’t care which).
In most programming languages there is no built-in support for concurrency,
and creating new threads has to be done via a platform and language
specific system/ library call. In the Java platform, we have to create an object
of type java.lang.Thread and call its method start (which is native, i.e., not
written in Java). The caller of start returns as for any method call, but there
is also a new thread competing for CPU time. The newly created thread must
have an entry point where it can start its execution. For this purpose there
must be a runnable object available to the thread object. A runnable object
provides a method run according to the interface java.lang.Runnable; that interface
simply declares a public void run() and nothing more. It is that run
method you should implement to accomplish the concurrent activity.
What run method to be called by start is determined at thread-object
creation time, i.e., when the thread object constructor is run. There are two
alternatives depending on what constructor that is used, extending a thread
object or implementing a runnable object:
• By extending class Thread, Runnable will be implemented since public
class Thread extends Object implements Runnable. In other words, this
will be an instance of Runnable. The default constructor will select
this.run as the beginning for the new thread.
Advantages with this alternative is that you can override also the start
method (to do some things before/after thread creation/termination,
calling super.start in between), utility methods of class Thread can be
called without qualification and asking the run-time system for the currently
executing thread (described in the sequel), and the inheritance
is a good basis for developing further threading subclasses (as done in
later chapters).
• By implementing the Runnable interface, the object can be passed to the
Thread constructor which then will use the run of the supplied object
as the beginning for the new thread. The advantage with this approach
is that the (in Java single) inheritance can be used for other purposes,
such as inheriting graphical properties.
In short, as indicated in the second item, which alternative that is most suitable
depends on the primary issue of the software. For instance, a graphical
3.1. Threads
43