Java: Multi tasks, Multi threading, Synchronization, Semaphore, Mutex, Barrier

Hi,

This post concerns the multi-tasking or multi-threading which is a programming technique to take advantage of the use of tasks (threads). We will see in this tutorial the practical implementation of a multi-tasking.

Firstly, to define what the multi-tasking, I propose several examples within an application:

• the GUI can start a thread to load a image while it continues to process events generated by user actions,
• a server application that waits for connection requests from clients, can initiate a process / thread to handle requests for multiple clients simultaneously,
• the multiplication of two matrices (m, p) and (p, n) may be carried out m * n parallel threads,

Below, some goals of multi-tasking:

• improve performance by distributing the different tasks on different processors,
• enjoy the break of a task (waiting for I / O or a user action) to do something else,
• faster response to user actions by rejecting a long and non-interactive task in another thread (example: corrections of spelling in a text editor),

However, there are also problems with multi-tasking:

• the difficulties of writing a multi-threaded program,
• the debugging of a program that uses the multi-tasking,

1) Notion of Process
Each process has an distinct address space (memory space where variables and objects are stored). Communication between processes can be achieved by:

• Signals,
• Tubes (pipes),
• Shared Memory,
• Sockets,
• …,

The java.lang.Runtime class:

• Allows the controls on the current process: Runtime.getRuntime(),
• Methods to know the runtime environment: total / free / MaxMemory(), availableProcessors(),
• Process Control: gc(), exit(), halt(),
• Creation of other processes: exec(),
• …,

The java.lang.Process class:

• Allows the controls on a child process,
• Creation of children processes: Runtime.getRuntime().exec(″command″),
• Control: waitFor(), exitValue(), destroy(), getInputStream(), getOutputStream(), getErrorStream(),
• …,

2) Notion of Thread
A thread allows run multiple portions of code simultaneously in the same process i.e. sharing the same memory space.
The Java environment is multi-threaded:

• Creating Threads,
• Synchronization of threads that share data,
• …,

3) Creating and launching Threads
In Java, a task is actually a class that implements the Runnable interface. This class must have a constructor and a “run” method, which will be called during the actual execution of the task:

The launch of a task will look like this:

• Creating an instance of the class are ExecutorService via the static method newFixedThreadPool of Executors class in taking as parameter the number of tasks required,
• Instantiate the class “MyTask” with a identifier parameter,
• Launch this task thanks to the execute method of ExecutorService class,
• Once the instructions of the task were performed, one calls the shutdown method,

4) A first example
The following class MyTask implements Runnable, so that each MyTask object can execute concurrently. A variable sleepTime stores a random integer value chosen when the MyTask constructor executes. Each thread running a MyTask object sleeps for the amount of time specified by the corresponding MyTask object’s sleepTime (for a certain number of milliseconds), then outputs its name.

MyTask.java

ApplicationLaunch.java

Outputs in console:

5) Synchronization
The use of threads can lead to synchronization requirements to avoid problems with concurrent access to global variables.
So for example, we throw 2 tasks:
– Their instructions will therefore execute simultaneously,
– If these instructions change a global variable in the program, then there will be a problem.

In parallel programming, a “critical section” is a piece of code that can be executed concurrently by multiple threads without risking operational anomalies. These “critical section” synchronized are also named thread-safe, they could be blocks of codes, methods or components like “Vector”, “Hastable”, “ConcurrentHashMap”, “CopyOnWriteArrayList” or “CopyOnWriteArraySet” (whereas the “ArrayList” and “HashMap” are not thread-safe).

Warning: The thread-safe components should be used when there are risks due to changes by multiple threads because they are less efficient than “normal” or classic components.

This is where we need to use methods of synchronization. So, it is necessary to avoid the simultaneous execution of critical sections by multiple threads:
– In Java, the synchronized keyword is used to synchronize threads and prevent them from performing at the same time, critical sections of codes,
– Several threads can run concurrently code synchronized to the same object.

There are 2 possibilities to synchronize code on a object “myObject”:

• Declare a synchronized method “myMethod” (Synchronization during the call of myObject.myMethod()):
  view source

  print?

  1	public synchronized int myMethod(...) { . . . }

• Use of a synchronized block on the object “myObject”:
view source

print?

1	synchronized(myObject) {

2	// synchronized codes

3

...

4

}

6) Semaphore
Java provides a class java.util.concurrent.Semaphore whose the constructor takes two parameters: an integer representing the current value of the semaphore that defines the number of resources available initially and a boolean indicating whether the method of administration must be FIFO.

Here we are going to develop the previous class MyTask and then synchronize two tasks to get a consistent outputs in console. In this example, the “acquire” method checks if the resource “semaphore” is available, whether this is the case then the semaphore is blocked by the current task, and this task is left to execute. Else the task is blocked until the resource “semaphore” is released by a call to “release” method (by an other task) that gives the resource.

MyTask.java

ApplicationSemaphore.java

Outputs in console:

Explanations:
The semaphore “personalSem” is initialized to 1 because it is necessary to have at least a resource initially available to execute the instructions when the method “acquire” will be called in the first task. The semaphore “neighboringSem” is initialized to 0 because in the second task, when the method “acquire” will be called, the task will be blocked because no (0) resource will be available.

An other example with 3 tasks:
ApplicationSemaphoreWith3Tasks.java

Outputs in console:

However, the execution of this example you will find probably that the message “end main task” is not appearing at the end of the execution of two tasks because it has not been synchronized and therefore it may appear at any time.

This will allow us to see a second mechanism is the synchronization barrier.

7) Barrier
Imagine a barrier which remains closed as the two tasks were not performed. Java proposes a class named java.util.concurrent.CountDownLatch which is similar to a barrier initially closed. A construction of this object, a counter block is initialized with the integer value passed as parameter.

So, this class “CountDownLatch” provides the method “await” allowing to tasksto wait the barrier’ survey. To decrement the counter value, it must call the “countdown”. When the counter value reaches 0, it is that all tasks have completed their work and therefore the barrier opens.

Here we are going to develop the previous class MyTask in order to synchronize the main thread and two tasks to get a consistent outputs in console.

MyTask.java

ApplicationBarrierSemaphore.java

Outputs in console:

8) Mutex
Finally, I would like expose you the MutEx (MUTual EXclusion). But what is it?
A Mutex is nothing but simple non-re entrant mutual exclusion lock. The lock is free upon construction. Each acquire gets the lock, and each release frees it. Releasing a lock that is already free has no effect. MUTEX is achieved in java by the keyword “synchronized” used when two or more methods try to access the same variables/Data structure. Mutex can be useful in constructions that cannot be expressed using java synchronized blocks because the acquire/release pairs do not occur in the same method or code block.

So, Java proposes a class named java.util.concurrent.locks.ReentrantLock:
“A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities.”

The main use of Mutex is sharing data or resources in a multitasking environment. For example, if a task changes and displays a variable, which must be protected during its modification. This requirement can be achieved through the use of semaphores, however, a lock or may be more practical.

Here we are going to develop the previous class MyTask in order to synchronize the main thread and two tasks to get a consistent outputs in console.

MyTask.java

ApplicationBarrierMutex.java

Outputs in console:

Here, this is an article that ends.

Best regards,

Huseyin OZVEREN

Download the sources of this article: java_thread_synchro.zip