Channel direction and select patterns in Go vs Java | Patterns, idioms, and best practices in Go

1. Channel direction — channel directions

In Go, channels can be one-way: only for sending or receiving. This helps to make function interfaces more safe and clear. For a Java developer, this is somewhat similar to BlockingQueue<Integer>, where producer/consumer use different methods put/take.

// Go: one-way channels
func sender(ch chan<- int) {
    ch <- 42
}

func receiver(ch <-chan int) {
    value := <-ch
    fmt.Println("Received:", value)
}

ch := make(chan int)
go sender(ch)
go receiver(ch)

// Java: BlockingQueue
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

Runnable producer = () -> queue.put(42);
Runnable consumer = () -> {
    Integer value = queue.take();
    System.out.println("Received: " + value);
};
new Thread(producer).start();
new Thread(consumer).start();

One-way channels improve readability and protect against accidental sending or receiving in the wrong place.

2. Select patterns with default

select allows non-blocking waiting for multiple channels, including default, to avoid blocking the goroutine. In Java, you have to combine poll(timeout) or check the queue manually.

// Go: select with default
select {
case val := <-ch1:
    fmt.Println("Received from ch1:", val)
case val := <-ch2:
    fmt.Println("Received from ch2:", val)
default:
    fmt.Println("Nothing is ready, continuing to work")
}

// Java: non-blocking check
Integer val1 = queue1.poll();
Integer val2 = queue2.poll();
if (val1 != null) {
    System.out.println("Received from queue1: " + val1);
} else if (val2 != null) {
    System.out.println("Received from queue2: " + val2);
} else {
    System.out.println("Nothing is ready, continuing to work");
}

Select with default allows goroutines to continue execution without blocking, which is especially useful for fan-in/fan-out and timeouts.

3. Comparison Table Go vs Java

Conclusion

Channels and select are key tools in Go for safe and efficient concurrent data processing. The direction of channels makes function interfaces safe and readable, while select with default helps avoid blocking and conveniently merge data from multiple sources. For Java developers, they are analogous to BlockingQueue with put/take and poll(), but Go provides a more lightweight and expressive syntax for concurrent patterns.