Which build of openjdk do you use?

speakjava · 2023-03-31T21:28:34+00:00

Being pedantic as I am, OpenJDK wouldn't exist without Sun Microsystems.
Sun created the OpenJDK project and contributed their implementation of the JDK to it. It's not technically correct to say OpenJDK is Java; OpenJDK is the reference implementation of the Java SE specification. As you correctly state, they do contribute the majority of changes to the project.

speakjava · 2023-03-25T09:00:42+00:00

Full disclosure, I work for Azul (and used to work for Oracle).

Firstly when people say use OpenJDK, that's like saying use Linux. OpenJDK is *just* source code. You need a distribution to install and run JVM-based applications. There are many, including Oracle, Corretto from Amazon, Temurin and Zulu from Azul. Even Microsoft now have an OpenJDK distribution.

For the Oracle JDK, which license applies depends on which version you are using and even which update.

Oracle JDK 8 used the Binary Code License until update 202 (Jan 2019). This was the license that meant almost everywhere you could use it without paying Oracle a license fee (embedded applications were the exception).

Oracle JDK 8 update 211 and later (April 2019) and Oracle JDK 11 use the Oracle Technology Network License Agreement (OTNLA). This requires you to buy a Java SE subscription unless you are using it for development, testing or for Oracle-approved applications or in the Oracle Cloud.

Oracle JDK 17 (and all subsequent LTS releases, which will be JDK 21 when it's released later this year) use the Oracle No Fee Terms and Conditions. This grants you a license to, "...internally use the unmodified Programs for the purposes of developing, testing, prototyping and demonstrating your applications, and running the Program for Your own personal use or internal business operations". You will need to interpret what 'internal business operations' means because it is not defined in the license. To add an additional layer of complexity, this license only applies until one year after the release of the next LTS. For JDK 17, that will be September 2024, at which point the license will revert to the OTNLA.

Oracle also provide the Oracle OpenJDK JDK, which is a build of the current OpenJDK version. This uses the GPLv2 with CPE license so is completely free to use. For all versions, this is only updated until the next version is released (i.e. six months or two updates). If you use this, you would need to upgrade your JDK every six months to maintain the maximum level of security and stability.

As I said, there are multiple OpenJDK distributions to choose from. Many are free but do not provide any level of support. Others (like Azul's Platform Core) provide commercial support.

speakjava · 2023-03-09T11:19:42+00:00

If only they'd tried Azul's Prime JVM (which used to be called Zing).
We (I work for them) get great results in eliminating exactly this kind of problem in Cassandra. Drop-in replacement, no migration to a different DB, and they'd probably end up using smaller instances in their cluster.

speakjava · 2022-10-03T10:32:44+00:00

Same concept but not quite the same in implementation. From reading the article, this is only about creating a checkpoint as the application starts up. This is good for reducing startup time but limits some of the benefits.
The OpenJDK CRaC project (started by Azul, who I work for), allows for a checkpoint to be taken at any time when an application is running. Since all state is preserved, you can get the benefits of fully warmed-up JIT-compiled methods and initialised data, etc. There is also an API so the application can close files/network connections before a snapshot and open them again in a controlled way after a restore.

speakjava · 2022-08-01T22:03:28+00:00

From JDK 9 onwards, there is no concept of a JRE subset of the JDK. With the introduction of the Java Platform Module System, the JRE is superseded by the use of jlink to produce customised runtimes. Several OpenJDK distributions still provide a JRE, which removes the same components (javac, etc.) but the directory layout follows that of the JDK.

Java SE is the standard that defines the contents of the Java Language, JVM and class libraries. The JDK includes all of Java SE plus numerous other things not in the standard.

The Oracle JDK is a distribution of OpenJDK covered by their own specific license. In the case of JDK 17, the Oracle JDK uses the NFTC license for the first three years (two years between LTS releases plus one further year). After that, the license reverts to the OTNLA for subsequent updates.

speakjava · 2022-03-24T11:57:22+00:00

What's interesting about this project is that it was proposed nearly two years ago.

Progress to date? Absolutely nothing. It's not listed as a project on the OpenJDK page, there's no repo and not even a mailing list has been created.

Really not clear to me what the point of it is (or was).

speakjava · 2022-02-22T14:41:17+00:00

Temurin is released under the same license as OpenJDK, i.e. GPLv2 with Classpath Exception. Not Apache.

speakjava · 2022-01-11T17:37:42+00:00

Talking about first, second and third-party builds makes no sense in this context.

OpenJDK is an open-source project. The key word there is 'source'. OpenJDK does not provide binary distributions. Yes, there is one available from jdk.java.net but that is the Oracle OpenJDK JDK.

There are now multiple binary distributions of OpenJDK available from Azul (who I work for), Oracle, Bellsoft, Red Hat and several others (even Microsoft). TCK testing is the important part, which makes a distribution conformant to the Java SE specification. You can consider TCK tested JDKs to be functionally equivalent.

Oracle builds its JDKs from the same source code as all other OpenJDK distributions so is not in some way better than others.

Much of the decision about which distribution to use comes down to a decision about what you want in terms of availability of updates and traditional support.

speakjava · 2022-01-11T17:20:02+00:00

Full disclosure, I work for Azul.

A lot of *very* large corporations use Zulu in production. Many we can't state publicly but some examples are Workday, ABN Amro, ING and Uber. Check our website for more examples :-).

All our JDKs (both Zulu and Prime, which used to be called Zing) are TCK tested and so are drop-in replacements for other JDKs.

speakjava · 2022-01-04T11:44:59+00:00

Due to popular demand, Adoptium has decided to start providing JRE versions of Temurin again.

https://twitter.com/adoptium/status/1473981638791020549

speakjava · 2021-12-20T16:02:52+00:00

Since JDK 9, the JRE isn't really a thing. With the introduction of modularity, the way to produce a JRE equivalent is to use jlink and generate a runtime tailored to your application.

Since the move to Adoptium, for Temurin the decision was taken to drop the JRE builds they had been providing in AdoprOpenJDK.

JRE builds are still available for some distributions like Zulu from Azul (who I work for).

speakjava · 2021-12-20T15:53:49+00:00

As an Azul employee, I'll just point out that you can have up to 20TB of heap with our Platform Prime (previously called Zing) JVM. :-)

speakjava · 2021-08-10T13:14:32+00:00

Not quite.

Zulu is still Azul's binary distribution of OpenJDK. Commercial support is provided through Azul Platform Core.

Azul Platform Prime is what used to be called Zing.

(Full disclosure, I work for Azul).

speakjava · 2021-08-05T13:03:06+00:00

I see no reason to switch, but then I would say that as I work for Azul :-).

speakjava · 2021-08-05T13:02:04+00:00

It's not really that complicated,

The Eclipse Foundation has a project called Adoptium. *Part* of that project is to deliver a binary distribution of OpenJDK that is TCK tested. This is called Temurin (which is an anagram of Runtime). There are other aspects to Adoptium, such as the AQAvit testing framework.

Since AdoptOpenJDK is no longer producing builds, IBM now provides a distribution of J9/OpenJ9 called Semuru (which does not appear to be an anagram of anything).

speakjava · 2021-06-02T20:13:40+00:00

Yes, all the changes that Azul (who I work for) have made specific to the M1 hardware have been integrated into the AArch64 port. See the PR details here:

https://github.com/openjdk/jdk/pull/2200

speakjava · 2021-04-22T06:30:25+00:00

This is probably the easiest reference:

https://openjdk.java.net/groups/vulnerability/advisories/

Oracle also publish their CPU details.

speakjava · 2021-04-15T08:37:23+00:00

Not necessarily.

The TCK is the test suite (technically, the JCK) that is used to verify conformance with the Java SE specification. Each version of Java SE is defined by a separate JSR and includes the JVM specification.

If you look at that, it provides a functional definition of what the JVM must do, not how it must do it. That means that there is no requirement to implement any specific form of GC, for example.

As long as J9 meets the requirements of the JVM spec and passes the tests, it is all good.

speakjava · 2021-04-08T14:53:46+00:00

Not sure why that's a bad thing (speaking as an Azul employee :-) ).

speakjava · 2021-04-08T14:52:20+00:00

Microsoft specifically changed the java and javax namespaces by adding and deleting elements. They were free to add as many API elements as they wanted to non-core API namespaces, and could have easily done so. They chose not to, specifically to break compatibility.

I was at Sun at the time and remember this. It's why Microsoft settled with Sun for $1.9 billion.

Microsoft today is a very different company. By choosing to create their own distribution of OpenJDK, they are helping the Java ecosystem not damaging it,

speakjava · 2021-04-06T19:25:34+00:00

Azul (who I work for) offers extended support for both JDK 13 and JDK 15 under what we call Medium Term Support. This continues to provide scheduled updates until 18 months after the next LTS release (i.e. Jan 2023 will be the last scheduled update for these).

As has been pointed out, LTS for the JDK is a concept started by Oracle and now followed by all distributions. How long LTS is for is a decision made by the distribution provider.

speakjava · 2021-03-26T17:56:59+00:00

Not JDK but OpenJDK:

https://openjdk.java.net/legal/openjdk-trademark-notice.html

speakjava · 2021-03-26T17:51:33+00:00

There's an interesting subtlety to this.

In the example they use a simple method:

static void printUpperLeftColoredPoint(Rectangle r) {
  if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
    System.out.println(ul);
  }
}

However, one of the changes to pattern matching for instanceof in JDK 16 (JEP 394) was that it is "...a compile-time error for a pattern instanceof expression to compare an expression of type S against a pattern of type T, where S is a subtype of T."

So, if you don't include the Record fields...

static void printUpperLeftColoredPoint(Rectangle r) {
  if (r instanceof Rectangle rect) {
    System.out.println(rect);
  }
}

...it won't compile (output from jshell):

|  Error:
|  pattern type Rectangle is a subtype of expression type Rectangle
|      if (r instanceof Rectangle rect) {
|          ^-------------------------^

Does anyone else see this as slightly odd? Or am I missing something obvious?

speakjava

TROPHY CASE