Tag: multi-threading

Cracking the Code: Solving the Producer-Consumer Problem in Java

Sean MayerLeave a comment

Hello, fellow coders! Today, let’s delve into a classic problem in concurrent programming – the Producer-Consumer Problem. We’ll solve this problem in Java, using its robust concurrency control mechanisms. Let’s get started!

Understanding the Problem

The Producer-Consumer problem is a classic example of a multi-process synchronization problem. Here, we have two processes: the producer, which generates data, and the consumer, which consumes it. The challenge lies in making sure that the producer won’t try to add data into a full buffer, and the consumer won’t try to remove data from an empty buffer.

Java Solution

Java’s java.util.concurrent package provides several classes that can help us solve this problem. We’ll be using BlockingQueue – a queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element and wait for space to become available in the queue when storing an element.

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Producer implements Runnable {
    private final BlockingQueue<Integer> sharedQueue;

    public Producer(BlockingQueue<Integer> sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("Produced: " + i);
                sharedQueue.put(i);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer implements Runnable {
    private final BlockingQueue<Integer> sharedQueue;

    public Consumer(BlockingQueue<Integer> sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                System.out.println("Consumed: " + sharedQueue.take());
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class ProducerConsumer {
    public static void main(String[] args) {
        BlockingQueue<Integer> sharedQueue = new LinkedBlockingQueue<>();

        Thread producerThread = new Thread(new Producer(sharedQueue));
        Thread consumerThread = new Thread(new Consumer(sharedQueue));

        producerThread.start();
        consumerThread.start();
    }
}

In this code, the producer produces a series of numbers, while the consumer consumes them. The put() method used by the producer will block if the queue is full, and the take() method used by the consumer will block if the queue is empty, thereby solving our problem.

Final Note

The Producer-Consumer problem provides a great opportunity to explore how Java handles concurrency and synchronisation. By leveraging Java’s inbuilt classes and methods, we can provide a simple and efficient solution to this problem. Always remember, concurrency control is an essential tool in your developer’s toolkit. So, keep practicing, keep coding, and until next time, happy learning!

Difference between wait() and notify() in Java

Sean MayerLeave a comment

To begin, the wait() and notify() methods belong to the Object class in Java. This is to replaces the need to poll conditions repeatedly until they meet consensus – the problem with this is that it eats a lot of CPU resources.

So what do they do? Let’s answer that question…

What does the wait() Method do?

  • Belongs to the java.lang.Objects class
  • The wait() method pauses the thread
    • To release the wait() there needs to be another live thread that invokes notify() or notifyAll() to unlock this thread

How can you call the wait method?

  • wait()
    • no args, will cause the thread to wait until notify() or notifyAll() is called
  • wait(long timeout)
    • One arg, this can either be released by notify() or notifyAll() or when the timeout elapses
  • wait(long timeout, int nanoseconds)
    • One arg, this can either be released by notify() or notifyAll() or when the timeout elapses with extra nanoseconds for precision

What does the notify() method do?

  • Belongs to the java.lang.Objects class
  • Used only to wake up one thread that’s waiting for an object

Here’s an example of how wait() and notify() can be used to synchronize two threads:

Code example!

wait() and notify() can be used to synchronise two threads:

class SharedObject {
    private boolean ready = false;
    public synchronized void setReady() {
        ready = true;
        notify();
    }
    public synchronized void waitUntilReady() {
        while(!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class ThreadA extends Thread {
    private SharedObject sharedObject;
    public ThreadA(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        // Do some work
        // ...
        // Set the shared object to "ready"
        sharedObject.setReady();
    }
}

class ThreadB extends Thread {
    private SharedObject sharedObject;
    public ThreadB(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        // Wait until the shared object is "ready"
        sharedObject.waitUntilReady();
        // Do some work
        // ...
    }
}

In this example, ThreadA sets the shared object to “ready” by calling the setReady() method, and ThreadB waits until the shared object is “ready” by calling the waitUntilReady() method. When ThreadA sets the shared object to “ready”, it also calls notify() on the shared object, which causes ThreadB to wake up and continue executing.

Note that using notify() will wake up only one thread waiting on the lock and using notifyAll() will wake up all the threads waiting on the lock.

Final Tip

It’s worth noting that in the example above, the wait() and notify() methods are used inside a synchronised block to ensure that only one thread can access the shared object at a time, which is necessary to prevent race conditions.

Difference between HashMap and HashTable in Java?

Sean MayerLeave a comment

Let’s begin with the similarities of HashMap and HashTable:

  • Both store key and value pairs in a hash table
  • Both declare an object which are both declared as a key
  • The key is hashed, and then this hash is indexed within the hash table it is stored

HashMap vs HashTable

HashMap

  • None-synchronised. Not thread safe, unable to be shared between other threads.
  • Allows for one null key and multiple null values
  • Preferred if thread synchronisation is not needed
  • Performance is high as threads are not required to wait
  • Introduced in 1.2
  • None legacy
  • Not good for multithreaded environments

HashTable

  • Synchronised. Thread safe, can be shared between other threads.
  • Does not allow for null values in key or value
  • Preferred if synchronisation is needed
  • Performance is impacted as waiting for threads
  • Introduced in 1.0
  • Legacy
  • Good for multithreaded environments

HashMap Example

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("apple", 5);
        map.put("banana", 3);
        map.put("orange", 10);

        int value = map.get("banana");
        System.out.println(value); // Output: 3

        map.remove("orange");
        map.put("orange", 8);

        System.out.println(map); // Output: {apple=5, banana=3, orange=8}
    }
}

HashTable Example

import java.util.Hashtable;

public class HashTableExample {
    public static void main(String[] args) {
        Hashtable<String, Integer> table = new Hashtable<>();
        table.put("apple", 5);
        table.put("banana", 3);
        table.put("orange", 10);

        int value = table.get("banana");
        System.out.println(value); // Output: 3

        table.remove("orange");
        table.put("orange", 8);

        System.out.println(table); // Output: {apple=5, banana=3, orange=8}
    }
}