Thread synchronization

Imagine you have a bunch of toys in a playroom, and many kids want to play with them at the same time. If everyone grabs a toy at once, chaos ensues! In programming, threads are like these kids, and thread synchronization is like teaching them to take turns and share the toys politely.

What are Threads?

In programming, a thread is like a mini-program running inside a bigger program. It’s like having multiple tasks happening simultaneously. For example, one thread might be playing music, while another checks for new messages on your phone.

Why Synchronization Matters

When multiple threads are working on the same data or resource (like the toys in the playroom), problems can occur if they don’t coordinate properly. Imagine if one thread is trying to read a variable while another is trying to change it at the same time – chaos! This can lead to bugs and unexpected behavior in your program.

Thread Synchronization in Java

In Java, you can use synchronization to make sure threads behave well together. There are different ways to do this, but one common method is using the synchronized keyword and the wait() and notify() methods.

Example: Sharing Toys (Threads) in Java

Let’s write some Java code to simulate our playroom scenario:

class ToyRoom {
    private int numOfToys = 5; // Let's say we have 5 toys

    // Method to let a kid play with a toy
    public synchronized void play() {
        while (numOfToys == 0) { // If there are no toys left
            try {
                wait(); // Kid waits until a toy becomes available
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        numOfToys--; // Kid takes a toy
        System.out.println("Kid plays with a toy. Remaining toys: " + numOfToys);
        notify(); // Notify other kids that a toy has been taken
    }

    // Method to return a toy to the room
    public synchronized void returnToy() {
        numOfToys++; // Kid returns a toy
        System.out.println("Kid returns a toy. Remaining toys: " + numOfToys);
        notify(); // Notify waiting kids that a toy is available
    }
}

class Kid extends Thread {
    private ToyRoom room;

    public Kid(ToyRoom room) {
        this.room = room;
    }

    public void run() {
        room.play(); // Kid plays with a toy
        // Simulate playing time
        try {
            sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        room.returnToy(); // Kid returns the toy
    }
}

public class Main {
    public static void main(String[] args) {
        ToyRoom room = new ToyRoom();
        // Let's create some kids (threads)
        for (int i = 0; i < 10; i++) {
            Kid kid = new Kid(room);
            kid.start(); // Start the kid thread
        }
    }
}

Explanation of the Code

• We have a ToyRoom class representing our playroom. It has methods play() and returnToy() to simulate a kid playing with a toy and returning it.
• The Kid class represents each thread (kid) playing with toys. Each kid tries to play with a toy and then returns it after some time.
• We create a ToyRoom object and multiple Kid objects (threads) in the Main class and start them.

How Synchronization Works

• We use the synchronized keyword in the play() and returnToy() methods to ensure that only one kid can play with a toy or return it at a time. This prevents conflicts when multiple kids try to access the toys simultaneously.
• The wait() method is called when a kid finds no toys available, causing the kid to wait until another kid returns a toy (notify() is called).
• The notify() method is called when a kid returns a toy, waking up one waiting kid to play with the toy.

Conclusion

Thread synchronization in Java helps ensure that threads (kids) share resources (toys) safely and avoid conflicts. By using synchronization techniques like synchronized blocks and methods, along with wait() and notify() methods, we can make our programs run smoothly even when multiple threads are working together.