Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
This article, one of the first ever published by JavaWorld, describes how threads are implemented in the Java programming language, starting with a general overview of threads.
Simply put, a thread is a program's path of execution. Most programs written today run as a single thread, causing problems when multiple events or actions need to occur at the same time. Let's say, for example, a program is not capable of drawing pictures while reading keystrokes. The program must give its full attention to the keyboard input lacking the ability to handle more than one event at a time. The ideal solution to this problem is the seamless execution of two or more sections of a program at the same time. Threads allows us to do this.
This article is part of the JavaWorld technical content archive. See the following to learn more about Java threads and concurrency:
Understanding Java threads (Java 101 series, 2002):
Also check the JavaWorld site map and search engine.
Multithreaded applications deliver their potent power by running many threads concurrently within a single program. From a
logical point of view, multithreading means multiple lines of a single program can be executed at the same time, however,
it is not the same as starting a program twice and saying that there are multiple lines of a program being executed at the
same time. In this case, the operating system is treating the programs as two separate and distinct processes. Under Unix,
forking a process creates a child process with a different address space for both code and data. However,
fork() creates a lot of overhead for the operating system, making it a very CPU-intensive operation. By starting a thread instead,
an efficient path of execution is created while still sharing the original data area from the parent. The idea of sharing
the data area is very beneficial, but brings up some areas of concern that we'll discuss later.
Java's creators have graciously designed two ways of creating threads: implementing an interface and extending a class. Extending
a class is the way Java inherits methods and variables from a parent class. In this case, one can only extend or inherit from
a single parent class. This limitation within Java can be overcome by implementing interfaces, which is the most common way
to create threads. (Note that the act of inheriting merely allows the class to be run as a thread. It is up to the class to
start() execution, etc.)
Interfaces provide a way for programmers to lay the groundwork of a class. They are used to design the requirements for a set of classes to implement. The interface sets everything up, and the class or classes that implement the interface do all the work. The different set of classes that implement the interface have to follow the same rules.