Understanding Concurrency

Introduction to Concurrency

Welcome to the first lesson in our "Introduction to Java Concurrency" course! In this lesson, we'll explore the fundamental concepts of concurrency and learn how to create and manage threads in Java. By the end, you'll be able to write your first multithreaded Java programs!

What You'll Learn

In this lesson, you'll be introduced to the fundamentals of concurrency in Java and learn how to create and manage threads effectively. The concept of concurrency and its significance in programming. Various benefits and challenges associated with concurrent programming. Differences between multithreading and multiprocessing . Two methods for creating threads in Java: extending the Thread class and implementing the Runnable interface. By the end of this lesson, you will have a solid foundation for building concurrent applications in Java.

What is Concurrency?

Concurrency is the ability of a system to handle multiple tasks simultaneously. This is crucial for optimizing resource utilization and improving application performance. Imagine a web server handling several client requests or a spreadsheet application allowing you to perform calculations while saving your work — these are real-world examples of concurrent programming. In Java, concurrency can help you make your applications more responsive and efficient. However, it also introduces challenges, such as managing data access and avoiding race conditions. Understanding these concepts is key to writing effective concurrent programs.

Multithreading vs. Multiprocessing

Multithreading Multithreading refers to multiple threads executing concurrently within a single process. Threads share the same memory space, making inter-thread communication simpler and more efficient. Multithreading is well-suited for tasks that need to perform multiple operations in parallel, such as handling user input while processing data. Multiprocessing Multiprocessing, on the other hand, involves multiple processes running concurrently, each with its own memory space. This approach is more resource-intensive, but it's beneficial for tasks that require heavy computational resources, as it allows for true parallelism across multiple CPU cores. In this course, we will primarily focus on multithreading in Java. Use Cases : Multithreading : Suitable for lightweight parallelism, such as handling multiple user requests in a web server. Multiprocessing : Ideal for CPU-bound tasks, like complex scientific calculations, which can benefit from separate memory spaces for processes.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Extending the Thread Class

Here's how to create a thread by extending the Thread class:

Java

public class HelloThread extends Thread {
    public HelloThread(String name) {
        super(name); // Calls the constructor of the Thread class to set the thread name
    }

    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

public class HelloThread extends Thread {
    public HelloThread(String name) {
        super(name); // Calls the constructor of the Thread class to set the thread name
    }

    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

In the above example, we define a class HelloThread that extends the Thread class. The run() method is overridden to specify the code that should execute in the new thread. The start() method is used to invoke run() in a new thread of execution.

Now, let's understand the implementation step by step.

Step 1:
Override the run() method available in the Thread class. This method provides an entry point for the thread, and you will put your complete business logic inside this method.

Java

public void run() {
    // Business logic goes here
}

public void run() {
    // Business logic goes here
}

Step 2:
Once a Thread object is created, you can start it by calling the start() method, which executes a call to the run() method.

Java

void start();

void start();

The start() method, when called, invokes the run() method in a new thread of execution. It’s important to understand that the start() method creates a separate thread, which runs concurrently with the main thread.

Here’s the Main class to run the thread:

Java

public class Main {
    public static void main(String[] args) {
        HelloThread thread = new HelloThread("HelloThread-1");
        thread.start(); // Creates a new thread of execution
    }
}

public class Main {
    public static void main(String[] args) {
        HelloThread thread = new HelloThread("HelloThread-1");
        thread.start(); // Creates a new thread of execution
    }
}

In this example, we create an instance of HelloThread, which is a subclass of Thread. By invoking start(), we initiate a new thread execution that runs the run() method defined in HelloThread. This allows our program to perform its tasks concurrently with the main thread.

Implementing the Runnable Interface

Here's how to create a thread by implementing the Runnable interface:

Java

public class RunnableDemo implements Runnable {
    private String threadName;

    public RunnableDemo(String name) {
        threadName = name;
    }

    @Override
    public void run() {
        System.out.println("Running " + threadName);
    }
}

public class RunnableDemo implements Runnable {
    private String threadName;

    public RunnableDemo(String name) {
        threadName = name;
    }

    @Override
    public void run() {
        System.out.println("Running " + threadName);
    }
}

In the above example, we define a class RunnableDemo that implements the Runnable interface. The run() method is implemented to specify the code that should execute in the thread.

Now, let's understand the implementation step by step.

Step 1:
Implement the run() method provided by the Runnable interface. This method provides an entry point for the thread, and you will put your complete business logic inside this method.

Java

public void run() {
    // Business logic goes here
}

public void run() {
    // Business logic goes here
}

Step 2:
Instantiate a Thread object using the following constructor:

Java

Thread(Runnable threadObj, String threadName);

Thread(Runnable threadObj, String threadName);

Where threadObj is an instance of a class that implements the Runnable interface, and threadName is the name given to the new thread.

Step 3:
Once a Thread object is created, you can start it by calling the start() method, which executes a call to the run() method.

Here's the Main class to run the thread:

Java

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo("Thread-1"));
        t1.start(); // Creates a new thread of execution
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableDemo("Thread-1"));
        t1.start(); // Creates a new thread of execution
    }
}

Here, we instantiate a Thread object by passing an instance of RunnableDemo to the Thread constructor. RunnableDemo implements the Runnable interface, and its run() method contains the code to be executed. Calling start() on the thread object begins a new thread execution, running the run() method concurrently with the main program thread.

Introduction to Concurrency

What You'll Learn

What is Concurrency?

Multithreading vs. Multiprocessing

Join the 1M+ learners on CodeSignal

Creating Threads in Java

Extending the Thread Class

Implementing the Runnable Interface

Extending Thread vs. Implementing Runnable

The Importance of Concurrency