Skip to content
Related Articles

Related Articles

Improve Article

Lambda Expressions | Concurrent Programming Approach 4

  • Difficulty Level : Easy
  • Last Updated : 08 Apr, 2019

Prerequisite: Different Approaches to Concurrent Programming in Java

Lambda expressions are very similar in behaviour to anonymous inner classes. They have complete access to code from surrounding classes including the private data. They are much more concise, succinct and readable. However, lambda expressions cannot have instance variables, so they do not maintain a state.

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

We can replace Anonymous Inner Class with Lambda Expression as follows:

Anonymous Inner Class:



    Thread thread = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("Printed inside Anonymous Inner Class!");
      }
    });

Lambda Expression:

Thread anotherThread = new Thread(() -> System.out.println(“Printed inside Lambda!”));

Practical Implementation:




import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
  
// Code for Concurrent programming using
// Lambda Expression
public class MyClass {
  
    // Driver method
    public static void main(String[] args)
    {
        new MyClass().startThreads();
    }
  
    // Starting threads with pool size as 2
    private void startThreads()
    {
        ExecutorService taskList
            = Executors.newFixedThreadPool(2);
  
        for (int i = 0; i < 5; i++) {
  
            int finalI = i + 1;
  
            // Prints thread name and value
            // of the counter variable
            taskList.execute(() -> {
  
                for (int j = 0; j < finalI; j++) {
  
                    System.out.println(
                        Thread
                            .currentThread()
                            .getName()
                        + " Counter:" + j);
                    pause(Math.random());
                }
            });
        }
        taskList.shutdown();
    }
  
    // Pauses execution allowing time for
    // system to switch back and forth
    private void pause(double seconds)
    {
        try {
            Thread.sleep(
                Math.round(1000.0 * seconds));
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Output:


pool-1-thread-1 Counter:0
pool-1-thread-2 Counter:0
pool-1-thread-2 Counter:1
pool-1-thread-2 Counter:0
pool-1-thread-1 Counter:0
pool-1-thread-2 Counter:1
pool-1-thread-1 Counter:1
pool-1-thread-2 Counter:2
pool-1-thread-1 Counter:2
pool-1-thread-2 Counter:0
pool-1-thread-1 Counter:3
pool-1-thread-2 Counter:1
pool-1-thread-2 Counter:2
pool-1-thread-2 Counter:3
pool-1-thread-2 Counter:4

Advantages: The user can easily access data in the main class including the private data. Lambdas are concise, succinct and readable.

Disadvantages: Lambdas are not allowed to have instance variables, thus we cannot pass arguments to run method. Also, we typically use lambdas when we have some shared data which invites the danger of race conditions.




My Personal Notes arrow_drop_up
Recommended Articles
Page :