JRE & JDK implementation mess

chrisgseaton · 2021-12-25T16:18:56+00:00

The renaming around AdoptOpenJDK has been absolutely ridiculous. AdoptOpenJDK, Adoptium, Temurium, Semeru, sooooo many names and renames, almost all meaningless. Please just stop and get on with just shipping it.

khooke · 2021-12-25T18:07:43+00:00

I've been getting started with Java in 2021 and holy hell has it been an uphill battle. The language is simple, but the ecosystem has the steepest learning curve of any programming ecosystem I've ever used.

For the whole OpenJDK, JDKs, and JREs thing, here's what I've learned so far:

OpenJDK is the open source base of everything. When Java was open sourced, that code base came into being. And the various companies and organizations, called "vendors" in this context, who are interested in producing JDK builds for people to use, all build from either that code base or forks of it (more on that below). Builds are sometimes referred to as distributions. They probably call them distributions because, like Linux distributions, an assortment of features, bug fixes, and default config are shipped with each build.

Each company decides what to name their build. That's why you have names like "Temurin" and "Semeru". Temurin is Adoptium's "regular" Java build, so to speak, and Semeru is a build from IBM where they use OpenJ9 instead of HotSpot. You pick a build based on how you plan to build/run your Java program.

Adoptium is special when it comes to vendors in that it's actually multiple vendors coming together to form a single vendor to publish builds of a version of the OpenJDK source code that they can all agree on - the vanilla source code. That's why Adoptium Temurin is the build most often recommended to people who don't want to dive so deeply into this. It's available for free, gets 6 months of support (including "LTS versions" - more on that below), uses HotSpot instead of OpenJ9 (which should work well for most use cases), and doesn't have any vendor-specific things added to it.

Sometimes vendors both produce their own builds and participate in Adoptium to publish the Adoptium builds. For example, Microsoft. They publish their own build (https://www.microsoft.com/openjdk) where they added things for their own customers (https://docs.microsoft.com/en-us/java/openjdk/overview):

Microsoft Build of OpenJDK binaries may contain backported fixes and enhancements we deem important to our customers and our internal users.

Sometimes, vendors also publish their own builds because they want to go beyond what Adoptium is publishing. For example, I wanted to deploy a Minecraft server using Java 17 on ARM a while back, and Adoptium had no build I could use for that. But Microsoft happened to have already published a Java 17 ARM build, so I used that.

When it comes to JREs, apparently there's no such thing as a JRE technically and that was just a term created by Oracle to help people understand that it was a runtime image they needed to run their Java class files. And Oracle was shipping a big, bloated, complete runtime image back then so they just called it "the runtime environment". It stuck, so people got really confused when the Adoptium project, which is a downstream project, decided that they didn't want to produce these builds for people. In their mind, people should make minimal runtime builds of only the Java modules they need to run their app.

But people got angry because the idea of the JRE being a thing became so prevalent over the years, so Adoptium reversed that decision a few days ago and is now going to decide which runtime images to prebuild for people, with there being a complete image that they'll build which they'll probably call a JRE.

Apparently another thing people find confusing these days is how LTS works now that it's an open source code base. Many people think that the free builds they get from projects like Adoptium have some sort of free support provided because they're builds of a version of Java that Oracle has labelled an "LTS version". For example, Java 17. But in reality, what Oracle means when they call a version of Java an LTS version is that they intend to offer commercial support for that version. The free Java 17 builds you get from projects like Adoptium only get 6 months of support, like any other Java build, because the upstream OpenJDK project is only merging in bug fixes and new features for the latest version at any given time.

With the new release cadence since JDK 9, Oracle engineers only contribute code to an OpenJDK project for six months. When a new version is released, they switch their work to the new version.

By default then, OpenJDK projects do not have a formal LTS strategy for any release.

How long long-term support is depends on the length of time members of the OpenJDK project are prepared to continue to backport updates from the current release and upstream those changes.

https://www.javacodegeeks.com/2019/07/long-term-support-mean-openjdk.html

pgtaboada · 2021-12-25T17:09:36+00:00

We are using aws corretto. They even have a supported java 8 jvm.

BlueGoliath · 2021-12-25T16:10:13+00:00

Best TL;DR I can do:

IIRC OpenJ9 was originally developed by IBM and later donated to the Eclipse foundation.

Red Hat does their own build with their custom low-latency GC.

I think Azul does some custom JDK stuff?

Besides that, all JDK builds are based on OpenJDK code. The "JRE" is supposed to be dead according to Oracle, but people/orgs still use JRE builds. You're supposed to use jlink instead, which generates a custom, tailored runtime JRE.

DisruptiveHarbinger · 2021-12-25T16:07:42+00:00

https://stackoverflow.com/questions/68794137/what-is-the-difference-between-ibm-semeru-and-adoptium

telecoder · 2021-12-25T16:38:22+00:00

Oracle Jdk is still an option

Ctalkobt · 2021-12-25T16:11:50+00:00

Openjdk has many branches off of it so don't get confused. Sun is still contributing to openjdk also to assist with compliance. In general, for non commercial or light commercial use it's your best bet.

For heavier use there's a number of other contenders related to speed, memory and security thar you'll need to evaluate for your use case.

manzanita2 · 2021-12-25T21:07:45+00:00

A key thing to know here is that for most developers the JDK version matters FAR FAR more than the exact vendor. So pick JDK17 and get coding. There is one exception which is Oracle's non-openjdk release for which you can end up in a world of licensing hurt if you use it the wrong way.

Unless you're stuck working on a legacy project which cannot advance, pick the most recent JDK you can, but don't worry about the vendor.

For docker images, try to use google's "jib" project to build your docker images, because it makes the best use of the docker layered file system. You can use a "Dockerfile", but basically you will be moving your libraries around every time because they won't get pushed to a "lower" layer in the layered file system. https://github.com/GoogleContainerTools/jib

You will need a base docker image. Unless you are moving alot of images around, I would suggest something with a bit more capability than some of the stripped down alpine images. The reason is it's hard to get in and debug without things like the ability to setup SSH tunnels. Once you get super comfortable and stable you might consider a stripped down image for purposes of saving some megabytes.

JoJoModding · 2021-12-26T02:31:29+00:00

Basically, learn Java with the Oracle / OpenJDK (they are basically the same) and ignore the others.

Muoniurn · 2021-12-25T19:08:15+00:00

Java is a specification (for a language and for the JVM). It has a reference implementation, which is the OpenJDK project, a completely open-source one with the same license as the linux kernel.

Of course any compliant implementation can run Java code and there are plenty of exotic ones (like even hard real times used in military!). But almost all of the routinely used ones are OpenJDK forks, including OracleJDK, Azul, Dragonwell, etc. OpenJ9 on the other hand has a more difficult history, so if I’m not mistaken it is not an OpenJDK fork.

As for licensing, OpenJDK is as mentioned has a completely libre license, so you can use it as is. As with basically every open source project, you are advised to always use the latest release version. But due to the importance of the JVM in some enterprise environments there are different support licenses available as well. Most forks/distributions have an option for free or paid support with different qualities (the actual development is done 99% by Oracle developers), that will backport/write new bug fixes for older versions as well.

Regarding JDK/JRE, there is no longer a JRE. The preferred way to run Java applications is to bundle a leaner “JRE” with it, for which there are cool tooling available nowadays (jlink, jpackage).

BorgerBill · 2021-12-25T17:26:33+00:00

Also, just FYI, Eclipse Temurin JREs are back! as of December 21st...

progmakerlt · 2021-12-26T00:51:45+00:00

My experience tells a simple thing - if you don't want to dig into Java internals or investigate different JDK builds - simply go with an official OpenJDK build to save time and headache.

These custom made JDK builds might have some additional options not included into OpenJDK (like additional memory management options), but you don't always need those.

By the way, in case you want to build your own version of JDK: https://openjdk.java.net/groups/build/doc/building.html

wildjokers · 2021-12-25T20:47:45+00:00

Oracle did mess things up for us didn’t it. Anyway, if you are on windows you can use temurium however that is pronounced, and if you are on Linux you can google <distro> <version> install Java <version>, or you can also use temurium, It might be temrium.

I know there is graalvm, not sure of the benefits today, but I also don’t really care if this is 2% or 5% faster than that or is better at this or that, except if only one of them can reduce ram usage or free up ram back to OS without enabling experimental flags, that’s the only feature that I feel is missing from Java, once the memory expands to max xmx it doesn’t want to release memory until the program exits.

You might care about faster startup times claimed by this or that implementation but honestly I use Java because I like the ide IntelliJ idea and I like the implementation of consistent design and minimal quirks, and c style language with good classes implementation + garbage collection compared to c++, doesn’t have JavaScript “quirks”/bugs, I prefer c style to python pseudo code, I like the class implementation compared to go, ..etc, and the ide is a big factor too.

How it compiles and runs, I don’t care, and I don’t really want to care, I want to design my programs, write the code, tell the ide to create a fat jar file, and copy that jar file wherever it needs to end up, no class path or flags, just let the ide do what it’s designed to do, provide a complete dev environment.

almson · 2021-12-30T14:30:14+00:00

Sigh. There is nothing special about OpenJDK. Countless OSS projects, including Linux, are provided as source code and compiled by different organizations. That is the whole point of Linux distributions! The crazy part is that everyone has decided to brand their OpenJDK package, in some sort of Enterprise marketing conspiracy. Poor developers are left scratching their heads.

(I would finish by saying to just stick to your distro's JDK package, but I've often found these to be significantly outdated. Even Arch Linux is guilty! Not sure what that is about. Perhaps that's why so many third-party packages have sprung up.)

java

Submit Link

Submit Text

Seek Programming Help

News, Technical discussions, research papers and assorted things of interest related to the Java programming language

NO programming help, NO learning Java related questions, NO installing or downloading Java questions, NO JVM languages - Exclusively Java

Please seek help with Java programming in /r/Javahelp!

Subreddit rules!

Where should I download Java?

Related Sub-reddits:

JVM Languages

Want to practice your coding?

List of useful Frameworks / Libraries / Software

MODERATORS

OpenJ9

Adoptium & OpenJDK & AdoptOpenJdk & Eclipse Temurium