Concurrency and parallelism in Java

-

 Concurrency and parallelism are two concepts in programming that deal with executing multiple tasks, but they differ in their approaches and purposes. Here’s a breakdown of each:

Concurrency

Concurrency is about dealing with multiple tasks at once but not necessarily executing them simultaneously. It allows a system to manage multiple tasks by interleaving their execution, giving the illusion that they are running in parallel.

  • Key Characteristics:

    • Task Interleaving: Multiple tasks make progress by being interleaved.
    • Context Switching: The system switches between tasks frequently.
    • Non-deterministic: The order of execution can vary.
    • Resource Sharing: Tasks share resources like CPU, memory, etc.

    In this example, thread1 and thread2 run concurrently, and the output will interleave the print statements from both threads.



public class ConcurrencyExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 1: " + i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread 2: " + i);
            }
        });

        thread1.start();
        thread2.start();
    }
}


Parallelism

Parallelism is about performing multiple tasks simultaneously. It requires multiple processors or cores and is a subset of concurrency. In parallelism, tasks actually run at the same time.

  • Key Characteristics:

    • Simultaneous Execution: Tasks run at the same time on multiple processors or cores.
    • Deterministic Execution: Tasks can be executed in a predictable manner if properly managed.
    • Resource Utilization: Efficient use of multiple processors or cores.
    In this example, the threads are managed to run in parallel using a parallel stream in Java. This requires multiple cores to truly run in parallel.





public class ParallelismExample {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Task 1: " + i);
                try {
                    Thread.sleep(100); // Simulate some work with a small sleep
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable task2 = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Task 2: " + i);
                try {
                    Thread.sleep(100); // Simulate some work with a small sleep
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // Run tasks in parallel
        Arrays.asList(task1, task2).parallelStream().forEach(Runnable::run);
    }
}

Comments

Post a Comment

Popular posts from this blog

Getting Started with the Java Flow API

-
Exploring the Java Flow API The Java Flow API, introduced in Java 9, provides a standard and efficient way for components of a reactive system to communicate with each other asynchronously, without requiring them to know each other's implementation details. In this post, we'll explore the key components of the Flow API and show how to use them to implement the Observer pattern in a more standardized way. Key Components of the Flow API The Flow API defines four key components: Publisher , Subscriber , Subscription , and Processor . Publisher A Publisher is a provider of data items, which publishes them to one or more Subscriber instances. To implement a custom Publisher, you need to implement the java.util.concurrent.Flow.Publisher interface, which defines the following methods: subscribe(Subscriber<? super T> subscriber) : Subscribes a Subscriber to this Publisher , returning a new Subscription instance that represents the connection between them. S...
Read more

Introduction to Lambdas in Java

-
Lambdas are a powerful addition to the Java language, introduced in Java 8, that allow developers to write more concise and readable code by representing functionality as a method argument or code block. In this post, we'll provide a complete introduction to lambdas in Java, including what they are, how they work, and some common use cases. What are Lambdas? In Java, a lambda expression is a short block of code that represents a method implementation. Lambdas provide a concise way to write code that can be passed around as a method argument or stored in a variable. Lambdas are often used in functional programming to represent behavior as data. Here's an example of a lambda expression in Java: Function<Integer, Integer> square = x -> x * x; This code defines a lambda expression that takes an integer as input, squares it, and returns the result. The lambda is assigned to a variable of type Function<Integer, Integer> , which represents a function that takes an ...
Read more