Lambda Expressions | Concurrent Programming Approach 4
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.
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.
Recommended Posts:
- Main App Implements Runnable | Concurrent Programming Approach 2
- Inner Class And Anonymous Inner Class that Implements Runnable | Concurrent Programming Approach 3
- Lambda Expressions in Java 8
- Different Approaches to Concurrent Programming in Java
- Need of Concurrent Collections in java
- Java.util.concurrent.Exchanger class with Examples
- Java.util.concurrent.Executor interface with Examples
- Java.util.concurrent.ExecutorService interface with Examples
- Java Lambda Expression with Collections
- Difference between Anonymous Inner Class and Lambda Expression
- Check if a string contains only alphabets in Java using Lambda expression
- Java.util.concurrent.RecursiveTask class in Java with Examples
- Java.util.concurrent.Phaser class in Java with Examples
- Java.util.concurrent.RecursiveAction class in Java with Examples
- Java.util.concurrent.Semaphore class in Java
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.




