Different Approaches to Concurrent Programming in Java

This article shows how to perform concurrent programming using Java threading framework. Let’s analyze concurrent programming first:

Concurrent Programming: This means that tasks appear to run simultaneously, but under the hood, the system might really be switching back and forth between the tasks. The point of concurrent programming is that it is beneficial even on a single processor machine.

Concurrent Programming on Single Processor Machine:

  1. Suppose the user needs to download five images and each image is coming from a different server, and each image takes five seconds, and now suppose the user download all of the first images, it takes 5 seconds, then all of the second images, it takes another 5 seconds, and so forth, and by the end of the time, it took 25 seconds. It is faster to download a little bit of image one, then a little bit of image two, three, four, five and then come back and a little bit of image one and so forth.
    
             Tasks overlap in time
    
    Task1   ------   ------   ------    ------ 
    
    Task2       ------   ------   ------   ------ 
    
            ------------------------------------------>
                                 Time
    
  2. If it takes 5 seconds for each one, and breaking it up into little chunks, the total sum is still 25 seconds. Then why is any faster to download it concurrently.
  3. It is because when the image from the first server is called and it takes 5 seconds, not because incoming bandwidth is maxed out, but because it takes a while for the server to send it to the user. Basically, the user sits around waiting most of the time. So, while the user is waiting for the first image, he might as well be starting to download the second image. So, if the server is slow, by doing it in multiple threads concurrently, one can download additional images without much extra time.
  4. Now eventually, if one downloads a lot of images concurrently, the incoming bandwidth might get maxed out and then adding more threads won’t speed it up, but up to a point, it’s kind of free.
  5. Besides speed, another advantage is decreased latency. Doing a little bit at a time decreases latency, so the user can see some feedback as things go along.

Need of Concurrent Programming

  • Threads are useful only when the task is relatively large and pretty much self contained. When the user needs to perform only a small amount of combination after a large amount of separate processing, there’s some overhead to starting and using threads. So if the task is really small, one never get paid back for the overhead.
  • Also, as mentioned above, threads are most useful when the users are waiting. For instance, while one is waiting for one server, the other can be reading from another server.

Basic Steps for Concurrent Programming

  1. Firstly to queue a task. The call executor service dots new fixed thread pool and supplies a size. This size indicates the maximum number of simultaneous tasks. For instance, if one add a thousand things to the queue but the pool size is 50, then only 50 of them will be running at any one time. Only when one of the first fifty finishes executing will 51st be taken up for execution. A number like 100 as pool size won’t overload the system.
    ExecutorService taskList = Executors.newFixedThreadPool(poolSize);
    
  2. The user then has to put some tasks of a runnable type to the tasks queue. Runnable is just a single interface that has one method called the run. System calls the run method at the appropriate time when it switches back and forth among the tasks by starting a separate thread.
     taskList.execute(someRunnable)
  3. Execute method is a little bit of misnomer because when a task is added to the task in the queue that is created above with executors dot new fixed thread pool, it doesn’t necessarily start executing it right away. It starts executing when one of those executing simultaneously(pool size) finishes execution.

There are five different approaches to implement concurrent programming with different advantages and disadvantages. We will discuss the first approach in this article and the remaining approaches in the subsequent articles.

Approach One: Separate Class that implements Runnable

  1. The first thing to do is to create a separate class, and an entirely separate class, that implements the runnable interface.
    public class MyRunnable implements Runnable {
             public void run() { ... }  
    }
  2. Secondly make some instances of the main class and pass them to execute. Let’s apply this first approach to making threads that just count. So, each thread will print the thread name, task number and counter value.
  3. Following this use the pause method to sit around waiting so that system switches back and forth. Print statements will thus be interleaved.
  4. Pass the constructor arguments to the constructor of the Runnable, so that different instances will count for a different number of times.
  5. Calling the shutdown method means shutting down the thread that’s watching to see if any new tasks have been added or not.

Practical Implementation

filter_none

edit
close

play_arrow

link
brightness_4
code

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
  
/**
* @author evivehealth on 08/02/19.
*/
// Java program depicting 
// concurrent programming in action.
  
// Runnable Class that defines the logic
// of run method of runnable interface
public class Counter implements Runnable 
{
    private final MainApp mainApp;
    private final int loopLimit;
    private final String task;
  
    // Constructor to get a reference to the main class
    public Counter
          (MainApp mainApp, int loopLimit, String task)
    {
        this.mainApp = mainApp;
        this.loopLimit = loopLimit;
        this.task = task;
    }
  
    // Prints the thread name, task number and 
    // the value of counter
    // Calls pause method to allow multithreading to occur
    @Override
    public void run()
    {
        for (int i = 0; i < loopLimit; i++) 
        {
            System.out.println("Thread: " +
            Thread.currentThread().getName() + " Counter: "
                             + (i + 1) + " Task: " + task);
            mainApp.pause(Math.random());
        }
    }
}
class MainApp 
{
  
    // Starts the threads. Pool size 2 means at any time
    // there can only be two simultaneous threads
    public void startThread()
    {
        ExecutorService taskList = 
                         Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) 
        {
            // Makes tasks available for execution.
            // At the appropriate time, calls run 
            // method of runnable interface
            taskList.execute(new Counter(this, i + 1,
                                    "task " + (i + 1)));
        }
  
        // Shuts the thread that's watching to see if 
        // you have added new tasks.
        taskList.shutdown();
    }
  
    // Pauses execution for a moment
    // so that system switches back and forth
    public void pause(double seconds)
    {
        try 
        {
            Thread.sleep(Math.round(1000.0 * seconds));
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
  
    // Driver method
    public static void main(String[] args)
    {
        new MainApp().startThread();
    }
}

chevron_right


Output:

Thread: pool-1-thread-1 Counter: 1 Task: task 1
Thread: pool-1-thread-2 Counter: 1 Task: task 2
Thread: pool-1-thread-2 Counter: 2 Task: task 2
Thread: pool-1-thread-1 Counter: 1 Task: task 3
Thread: pool-1-thread-2 Counter: 1 Task: task 4
Thread: pool-1-thread-1 Counter: 2 Task: task 3
Thread: pool-1-thread-1 Counter: 3 Task: task 3
Thread: pool-1-thread-1 Counter: 1 Task: task 5
Thread: pool-1-thread-2 Counter: 2 Task: task 4
Thread: pool-1-thread-2 Counter: 3 Task: task 4
Thread: pool-1-thread-1 Counter: 2 Task: task 5
Thread: pool-1-thread-2 Counter: 4 Task: task 4
Thread: pool-1-thread-1 Counter: 3 Task: task 5
Thread: pool-1-thread-1 Counter: 4 Task: task 5
Thread: pool-1-thread-1 Counter: 5 Task: task 5

Advantages:

  • Loose Coupling: Since a separate class can be reused, it promotes loose coupling.
  • Constructors: Arguments can be passed to constructors for different cases. For example, describing different loop limits for threads.
  • Race Conditions: If the data has been shared, it is unlikely that a separate class would be used as an approach and if it does not have a shared data, then no need to worry about the race conditions.

Disadvantages:
It was a little bit inconvenient to call back to the main application. A reference had to be passed along the constructor, and even if there is access to reference, only public methods(pause method in the given example) in the main application can be called.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.