Data Sharing and Synchronization

Synchronization and Data Sharing Between Threads

Welcome back to our journey into concurrency in Java! In our last lesson, we explored the thread lifecycle and fundamental thread operations. We learned about different thread states and key methods such as start(), sleep(), and join() . This foundational knowledge will serve us well as we now dive into an essential aspect of concurrency: synchronization and data sharing between threads .

What You'll Learn

In this lesson, you will gain the knowledge necessary to manage shared data between threads and prevent common concurrency issues: Understand how threads can share data through shared variables. Recognize the risks of unsynchronized data access and race conditions. Learn how to use the synchronized keyword to prevent concurrency issues. This lesson will equip you with practical skills for managing shared data safely in a concurrent environment.

Shared Variables and Synchronization

When multiple threads operate on shared variables, it can lead to data inconsistencies and unpredictable behavior if not managed correctly. Shared variables are pieces of data that multiple threads access and modify simultaneously, such as instance fields in a class or elements of a shared collection. Shared access allows threads to communicate and collaborate effectively, but without proper management, it introduces significant risks. Let’s explore the common problems with shared variables in a multithreaded environment.

Common Issues with Shared Variables

When multiple threads access shared data without appropriate control, it can lead to: Race Conditions : These occur when two or more threads try to modify a shared variable concurrently, leading to inconsistent results. For example, if multiple threads attempt to increase a shared counter at the same time, some increments may be lost due to overlapping access. Non-Atomic Operations : Operations like incrementing a shared counter (count++) involve multiple steps: reading the current value, incrementing it, and then writing it back. These steps can be interrupted by other threads if they are not synchronized, resulting in unpredictable behavior and incorrect results.

Join the 1M+ learners on CodeSignal

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

Running Threads with Shared Data

Let’s create two threads that increment a shared counter 1000 times each. This will illustrate how synchronization ensures data integrity:

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count with synchronization: " + counter.getCount());
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) counter.increment(); });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count with synchronization: " + counter.getCount());
    }
}

Here’s what’s happening:

Shared Counter: We create a SynchronizedCounter instance, which will be incremented by two threads.
Creating Threads:
- Two threads (t1 and t2) are created using the Thread class constructor, each taking a Runnable as a parameter.
- The lambda expression (() -> { for (int i = 0; i < 1000; i++) counter.increment(); }) is a shorthand way to define the run() method of a Runnable implementation.
Starting Threads:
- Calling t1.start() and t2.start() moves the threads from the NEW state to the RUNNABLE state, starting their execution concurrently.
Joining Threads: We use t1.join() and t2.join() to ensure that the main thread waits for both threads to finish before printing the result.

The synchronized keyword in the increment() method ensures only one thread modifies count at a time, preventing race conditions. Without it, the final count may be less than 2000 due to overlapping operations and lost updates.

Synchronization and Data Sharing Between Threads

What You'll Learn

Shared Variables and Synchronization

Common Issues with Shared Variables

Join the 1M+ learners on CodeSignal

Understanding Shared Data with Synchronization

Running Threads with Shared Data

Using the `synchronized` Keyword

Importance of Synchronization