Non Blocking Channel Operations in Mercury

Our example demonstrates non-blocking channel operations using Java’s BlockingQueue interface and its implementation LinkedBlockingQueue. While Java doesn’t have built-in channels like Go, we can simulate similar behavior using these classes.

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

public class NonBlockingQueueOperations {
    public static void main(String[] args) {
        BlockingQueue<String> messages = new LinkedBlockingQueue<>();
        BlockingQueue<Boolean> signals = new LinkedBlockingQueue<>();

        // Here's a non-blocking receive. If a value is
        // available in `messages` then `poll` will return
        // that value. If not, it will immediately return null.
        String msg = messages.poll();
        if (msg != null) {
            System.out.println("received message " + msg);
        } else {
            System.out.println("no message received");
        }

        // A non-blocking send works similarly. Here `offer`
        // attempts to add the element to the queue without
        // blocking. It returns true if successful, false otherwise.
        msg = "hi";
        if (messages.offer(msg)) {
            System.out.println("sent message " + msg);
        } else {
            System.out.println("no message sent");
        }

        // We can use multiple queues to implement a multi-way
        // non-blocking select. Here we attempt non-blocking
        // receives on both `messages` and `signals`.
        String receivedMsg = messages.poll();
        Boolean receivedSignal = signals.poll();

        if (receivedMsg != null) {
            System.out.println("received message " + receivedMsg);
        } else if (receivedSignal != null) {
            System.out.println("received signal " + receivedSignal);
        } else {
            System.out.println("no activity");
        }
    }
}

In this Java code:

We use BlockingQueue<String> and BlockingQueue<Boolean> to simulate channels.
The poll() method is used for non-blocking receives. It immediately returns null if the queue is empty.
The offer(E e) method is used for non-blocking sends. It returns false if the element cannot be added at the time of the call.
To simulate a multi-way select, we perform multiple poll() operations and check the results.

Note that this Java implementation doesn’t provide the exact same semantics as Go’s select statement. In particular, if multiple queues have data available, this implementation will always check them in the same order, whereas Go’s select chooses randomly among ready cases.

To run this program:

$ javac NonBlockingQueueOperations.java
$ java NonBlockingQueueOperations
no message received
no message sent
no activity

This example demonstrates how to perform non-blocking operations on queues in Java, which can be useful in concurrent programming scenarios where you don’t want your threads to block indefinitely.

Timeouts in Mercury

Closing Channels in Mercury

Learn X By Example

Title here

Non Blocking Channel Operations in Mercury