Introduction to Multithreading in Java

Processes vs Threads

  • Processes are heavyweight tasks that require their own separate address spaces.

    • Inter-process communication is expensive and limited.

    • Context switching from one process to another is also costly.

  • Threads share the same address space and the same process.

    • Threads require less overhead than processes.

    • Inter-thread communication is inexpensive, and

    • context switching from one thread to next is also of low cost.

 

Multitasking vs Multithreading

  • There are two types of multitasking:

    • process-based (usually referred to simply as multitasking

      • the computer runs two or more programs (or processes) concurrently (e.g. a notepad and another program).

      • Here, a program is the smallest unit of code that can be dispatched by the scheduler.

    • thread-based (usually referred to as multithreading).

      • a single program performs two or more tasks simultaneously through two more threads.

      • Each thread defines a separate path of execution that can run in parallel.

      • Here, the thread is the smallest unit of code that can be dispatched.

 

Thread states

A thread can be in one of the different states: New, Runnable, Running, Blocked and Terminated/Dead.

  • When a thread object is created (e.g. Thread t = new Thread();) it is in New state.

  • Once you invoke the threadObject's start() method (e.g. t.start()), the new thread will become runnable. Runnable threads are ready to run, but not running. After a suspended or blocking state also, a thread will become runnable.

  • If there are many threads in the runnable state, thread scheduler will select one thread and make it running. A thread is in running state when it is currently executed by the processor. Only one thread per processor can be running at any particular time though we might not actually feel it.

  • A thread can be suspended, sent to sleep or waiting, which causes the thread to go to blocked state. Once the blocked state is over, the thread goes to runnable state.

  • At any time, a thread can be terminated, when the run() method gets completed or through an exception that halts its execution. Once terminated, a thread cannot be resumed and trying to do so will throw an IllegalStateException. This is called the dead state.

 

Creating Threads

You can create threads directly instantiating a Thread class or using the newer better and safer concurrency package features such as Executors.

Though it is not preferred to create threads directly in new code, learning to create threads directly working with Thread class helps to understand basics well. We will see it next and later we will also see Executors.

Search the Web

Custom Search

Searches whole web. Use the search in the right sidebar to search only within javajee.com!!!