DEV Community: Partha Sutradhar

Multithreading - Dining Philosophers Problem in Java

Partha Sutradhar — Thu, 14 Mar 2024 15:05:42 +0000

Introduction

The Dining Philosophers Problem illustrates concurrency challenges, where philosophers seated at a table must pick up chopsticks to eat, leading to potential deadlock.

Solution

Chopstick Class: Implements locking mechanisms for chopstick pickup and put down.

public class Chopstick {
    private final Lock lock = new ReentrantLock();
    private final Logger logger = LoggerFactory.getLogger(Chopstick.class);
    public boolean pickUp() {
        try {
            return lock.tryLock(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }
    public void pickDown() {
        lock.unlock();
    }
}

Philosopher Class: Represents each philosopher, managing chopstick pickup and eating.

public class Philosopher implements Runnable {
    private final Logger logger = LoggerFactory.getLogger(Philosopher.class);
    private int id;
    private Chopstick leftStick;
    private Chopstick rightStick;

    public Philosopher(int id, Chopstick leftStick, Chopstick rightStick) {
        this.id = id;
        this.leftStick = leftStick;
        this.rightStick = rightStick;
    }

    @Override
    public void run() {
        while (true) {
            try {
                logger.info("Philosopher " + id + " is thinking.");
                if (leftStick.pickUp()) {
                    logger.info("Philosopher " + id + " picked up left stick.");
                    if (rightStick.pickUp()) {
                        logger.info("Philosopher " + id + " picked up right stick.");
                        logger.info("Philosopher " + id + " is eating.");
                        rightStick.pickDown();
                        logger.info("Philosopher " + id + " pick down right stick.");
                    }
                    leftStick.pickDown();
                    logger.info("Philosopher " + id + " pick down left stick.");
                }
            } catch (Exception e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }
}

Main Class (Driver): Sets up philosophers and chopsticks, employing thread pooling for execution.

public class Driver {
    private static final Logger logger = LoggerFactory.getLogger(Driver.class);
    private static final Philosopher[] philosophers = new Philosopher[5];
    private static final Chopstick[] chopsticks = new Chopstick[5];

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5, runnable -> {
            Thread thread = Executors.defaultThreadFactory().newThread(runnable);
            thread.setPriority(Thread.MAX_PRIORITY);
            return thread;
        });
        for (int i = 0; i < chopsticks.length; i++) {
            chopsticks[i] = new Chopstick();
        }
        for (int i = 0; i < philosophers.length; i++) {
            philosophers[i] = new Philosopher(i + 1, chopsticks[i], chopsticks[(i + 1) % 5]);
            executorService.execute(philosophers[i]);
        }
    }
}

Conclusion

By synchronizing chopstick access and implementing a thoughtful eating protocol, we ensure the philosophers can dine peacefully without encountering deadlock or contention issues.

Design Callback Pattern in Java for WorkerContext

Partha Sutradhar — Sat, 11 Nov 2023 06:48:30 +0000

Introduction

Callbacks are a prominent programming paradigm in Java that is used for asynchronous and event-driven programming. Callbacks were traditionally created and used by establishing interfaces and putting them into anonymous inner classes, which could result in verbose and crowded code. But lambda expressions, which offer a more concise and expressive method of working with callbacks, were introduced in Java 8.

We'll look at a real-world example in this blog article to see how lambda expressions can make using callbacks in Java easier. We will compare the lambda approach with the old method using a WorkerContext class that uses callbacks to accomplish some work.

Design Callback Pattern

Let's begin by discussing the traditional approach to callbacks pattern in Java.

interface Callback {
    void call(int data);
}

class WorkerContext {
    private Callback callback;

    public WorkerContext() {}

    public WorkerContext(Callback callback) {
        this.callback = callback;
    }

    public void startWork(int min, int max) {
        if (callback != null) {
            callback.call(ThreadLocalRandom.current().nextInt(min, max + 1));
        }
    }
}

The conventional way involves defining a Callback interface with a single call method, utilising an anonymous inner class to generate an instance of the interface, and passing it to the WorkerContext.

Traditional Way

class Solution {
    public static void main(String[] args) {
        Callback callback = new Callback() {
            @Override
            public void call(int data) {
                System.out.println("Random : " + data);
            }
        };
        WorkerContext workerContext1 = new WorkerContext(callback);
        workerContext1.startWork(0, 100);
    }
}

Lambda Way

Now, let's explore how lambda expressions can simplify the callback process.

class Solution {
    public static void main(String[] args) {
        WorkerContext workerContext2 = new WorkerContext((count) -> System.out.println("Random : " + count));
        workerContext2.startWork(0, 100);
    }
}

When constructing the WorkerContext instance via the lambda method, we explicitly describe the callback at that point. As a result, anonymous inner classes and a separate interface specification are not required.

Conclusion

Using functional programming concepts in your Java applications is made possible by adopting the lambda approach, which also increases code readability and maintainability.

Build Step Builder Pattern to Enforce Client code to Provide data.

Partha Sutradhar — Sun, 05 Nov 2023 10:35:24 +0000

Introduction

The step builder pattern ensures that clients supply all essential information for constructing an object. In the DataSourceConfiguration example, clients must specify the host, port, username, and password. SSL configuration is optional.

Configuration the Datasource

The DataSourceConfiguration class is a builder pattern that allows a client to create a DataSourceConfiguration object by providing a series of steps. The steps are:

Step 1: Configure the host of the data source.
Step 2: Configure the port of the data source.
Step 3: Configure the username for accessing the data source.
Step 4: Configure the password for accessing the data source.
Step 5:(Optional) Configure whether to use SSL when connecting to the data source.

DataSourceConfiguration configuration = DataSourceConfiguration.Builder()
  .withHost("localhost") // required
  .withPort(3306) // required
  .withUser("root") // required
  .withPassword("password") // required
  .build();

Configuration of Step Builder

public class DataSourceConfiguration {

    private final String host;
    private final int port;
    private final String username;
    private final String password;
    private final boolean useSSL;

    private DataSourceConfiguration(Builder builder) {
        this.host = builder.host;
        this.port = builder.port;
        this.username = builder.username;
        this.password = builder.password;
        this.useSSL = builder.useSSL;
    }

    public interface HostStep {
        PortStep withHost(String host);
    }

    public interface PortStep {
        UserStep withPort(int port);
    }

    public interface UserStep {
        PasswordStep withUser(String username);
    }

    public interface PasswordStep {
        BuildStep withPassword(String password);
    }

    public interface BuildStep {
        BuildStep withSSL(boolean useSSL);

        DataSourceConfiguration build();
    }

    public static class Builder implements HostStep, PortStep, UserStep, PasswordStep, BuildStep {
        private String host;
        private int port;
        private String username;
        private String password;
        private boolean useSSL;

        @Override
        public PortStep withHost(String host) {
            this.host = host;
            return this;
        }

        @Override
        public UserStep withPort(int port) {
            this.port = port;
            return this;
        }

        @Override
        public PasswordStep withUser(String username) {
            this.username = username;
            return this;
        }

        @Override
        public BuildStep withPassword(String password) {
            this.password = password;
            return this;
        }

        @Override
        public BuildStep withSSL(boolean useSSL) {
            this.useSSL = useSSL;
            return this;
        }

        public DataSourceConfiguration build() {
            return new DataSourceConfiguration(this);
        }
    }
}

Conclusion

The builder pattern is a valuable technique for enhancing code usability and maintainability. It guarantees that clients supply all necessary data for creating an object and improves code readability and comprehension.

Building Generic Payloads with the Builder Pattern in Java

Partha Sutradhar — Mon, 30 Oct 2023 16:07:16 +0000

Java Generics can be used to create reusable code for structured responses in web services. This makes the code easier to maintain and scale. Generics allows the Payload class to be flexible, reusable, and consistent for backend and client-side developers.

Introduction

A well-structured response from a backend service provides clear information about the outcome of the request, any relevant data, any associated messages, and often metadata such as the timestamp.

Structured responses from backend services

A well-structured response from a backend service:

Provides clarity about the outcome (success or failure).
Contains any relevant data related to the response.
May provide any associated message with the response.
Often includes metadata, like the timestamp.

Using Generics to define a response

Consider the Payload class provided. Here's a breakdown of how it's structured:

Message: A description of the outcome of the request, such as "Request Successful" or "Item not found."
Status: A numerical status code, such as 200 for OK or 404 for NOT FOUND.
Payload: The actual data being sent in the response. This can be of any type, thanks to the use of Generics.
Timestamp: The time at which the response was created.

In short: The Payload class provides a structured way to represent backend responses, with fields for the message, status, payload, and timestamp.

Using the Builder Pattern

The builder pattern allows us to construct Payload objects in a more expressive way, as shown in the following example:

Payload<String> successPayload = new Payload.Builder<String>()
                                    .message("Request successful")
                                    .status(PayloadStatus.SUCCESS)
                                    .payload("This is the response data")
                                    .build();

Benefits

Flexible: Payload can be of any type, thanks to Generics.
Reusable: A single Payload class can be used for many different response types.
Consistent: All responses have a consistent structure.

Usage

// Create a Payload with a String payload.
Payload<String> successPayload = new Payload.Builder<String>()
  .message("Request successful")
  .status(PayloadStatus.SUCCESS)
  .payload("This is the response data")
  .build();

// Create a Payload with a User object payload.
User user = new User("John", "Doe");
Payload<User> userPayload = new Payload.Builder<User>()
  .status(PayloadStatus.SUCCESS)
  .message("User found")
  .payload(user)
  .build();

// Create a Payload with a List of Items payload.
List<Item> items = Arrays.asList(new Item("Book"), new Item("Pen"));
Payload<List<Item>> itemsPayload = new Payload.Builder<List<Item>>()
  .status(PayloadStatus.SUCCESS)
  .message("Items fetched")
  .payload(items)
  .build();

// Create a Payload with an error message.
Payload<Void> errorPayload = new Payload.Builder<Void>()
  .status(PayloadStatus.ERROR)
  .message("Something went wrong!")
  .build();

Payload Builder Pattern

The Payload Builder Pattern is a design pattern that allows you to create complex objects in a step-by-step manner. It is especially useful for creating objects with many optional parameters.

@Getter
@ToString
public class Payload<T> {
    private final String message;
    private final int status;
    private final T payload;
    private final Date timestamp;

    private Payload(PayloadStatus status, String message, T payload) {
        this.status = status.getCode();
        this.message = message;
        this.payload = payload;
        this.timestamp = Date.from(Instant.now().atZone(ZoneId.of("UTC")).toInstant());
    }

    public static class Builder<T> {
        private String message;
        private PayloadStatus status;
        private T payload;

        public Builder<T> message(String message) {
            this.message = message;
            return this;
        }

        public Builder<T> status(PayloadStatus status) {
            this.status = status;
            return this;
        }

        public Builder<T> payload(T payload) {
            this.payload = payload;
            return this;
        }

        public Payload<T> build() {
            return new Payload<>(status, message, payload);
        }
    }
}

Conclusion

The Payload class with builder pattern is a flexible, reusable, and consistent way to represent responses from a backend service. It is easy to use and can be applied to a variety of use cases.