Hacker News Reader

Comment by za3faran | Hacker News Reader

Arguably, Java's virtual (green) threads managed through structured concurrency and futures is a superior approach.

Arguably, being 10 years late to the party is pretty bad.

Just how Go adding generics to the language didn't magically fix the billions lines of non-generic Go code, adding virtual threads to Java didn't update its entire ecosystem to take advantage of them.

Meanwhile, the entire Go ecosystem from the beginning took advantage of goroutines, so all code you'll ever interact with will have excellent support for them.

If you make use of a 30 years of library that does simple blocking IO and you call that library from a virtual thread you literally have non-blocking behavior - so your "didn't update it's entire ecosystem" is plain wrong. It's also just a Thread, so even consuming virtual threads by old libs is just fine.

Also, what 'party'? There is java, go, Haskell and erlang with anything similar. The majority of programming languages don't have such a feature so it's pretty questionable use of word to "be late".

Trust me. That's a common argument used when java introduces new features. Wait you see the same argument once value classes come to jdk 28.

I find that very debatable. Spring Boot, for instance, is just one config line away from automatically using virtual threads in its handlers:

    spring.threads.virtual.enabled=true

We also see library implementations switching to them.

Depends on what you're solving for. Message passing is fine. That's all channels does.

> superior approach

superior how -- What does it do better over Go channels in your opinion?

Superior in ergonomics - launching several async tasks and combining their results via futures is is much easier compared in Java compared to to Go's low-level, primitive way of doing things. No need to explicitly create channels and wait on them. Go doesn't expose Go-routines as a type and hence you are brow-beaten into laboriously using channels even when there is no real need to do so. I guess this could be all sorted out if the Go stdlib offered some convenient structured concurrency packges.

This is why sync.WaitGroup exists, but you have to manage the lifecycle explicitly, it’s not built into the language.

While stdlib doesn't handle this, there are libraries that can support your use case https://github.com/jizhuozhi/go-future

If you only need to launch work and wait for completion, Go 1.25 has sync.WaitGroup.Go -> wg.Go(f) -> by wg.Wait(). No channels like the page says.

Reply on news.ycombinator.com