Let's talk about the Java Valhalla Project

This article brings you relevant knowledge about java, which mainly introduces the introduction of the Java Valhalla Project and a detailed introduction around the theme. Let’s take a look at it together. I hope it will be helpful to everyone. helpful.

Recommended study: "java Video Tutorial"

In this article, we will introduce the Valhalla project - its historical reasons , the current state of development, and what it will bring to everyday Java developers after its release.

Motivation and reasons for the Valhalla project

Oracle's Java language architect Brian Goetz said in a speech that one of the main motivations for the Valhalla project is the desire to adapt the Java language and runtime to modern hardware. . When the Java language was born (at the time of writing about 25 years ago), access to memory and arithmetic operations cost about the same.

Today, this situation has changed, and memory fetch operations are 200 to 1000 times more expensive than arithmetic operations. In terms of language design, this means that indirect operations that result in pointer extractions can adversely affect overall performance.

Since most Java data structures in an application are objects, we can think of Java as a Pointer-intensive language (although we usually don't see or manipulate them directly) . This pointer-based object implementation is used to enable object identification, which itself is used for language features such as polymorphism, mutability, and locking. By default, these properties apply to every object regardless of whether they are actually needed.

Following the chain of identifiers leading to pointers and the chain of pointers leading to indirection, indirection has a performance drawback and the logical conclusion is to delete those data structures that do not require them. This is where value types come into play.

Value Types Value Types

The concept of value types is to represent pure data aggregation. This removes functionality from regular objects. So we have pure data, no identity. Of course, this means that we also lose the functionality that can be achieved using object identification. Therefore, equality comparisons can only be made based on status. Therefore, we cannot use representation polymorphism, nor can we use immutable or non-nullable objects.

Since we no longer have object identifiers, we can abandon pointers and change the general memory layout of value types instead of objects. Let's compare the memory layout between class points and corresponding value type points.

The code and corresponding memory layout of the regular Point class are:

final class Point {
  final int x;
  final int y;
}

On the other hand, the value type Point The code and corresponding memory layout would be:

value class Point {
  int x;
  int y
}

This allows the JVM to flatten value types into arrays and objects, as well as other value types.

In the image below, we show the indirect negative effects when using the Point class in an array:

On the other hand, Here we see the corresponding memory structure for the value type Point[]:

It also enables the JVM to pass value types on the stack without having to Allocate them on the heap. In the end, this means that we get data aggregations with runtime behavior similar to Java primitives like int or float.

But unlike primitives, value types can have methods and fields. We can also implement interfaces and use them as generic types.

Therefore, we can look at value types from two different perspectives:

• Faster objects
• User-defined primitives

As an extra icing on the cake, we can use value types as generic types without boxing. This leads us directly to another big project Valhalla feature: specialized generics.

Specialized Generics

When we want to generalize a language primitive, we currently use boxed types, such as integer representationIntegeror floating point representation Float. This boxing creates an extra layer of indirection, thereby defeating the purpose of using primitives to improve performance in the first place.

As a result, we see many specializations for primitive types in existing frameworks and libraries, such as IntStream<t></t> or ToIntFunction<t></t> . This is done to maintain the performance improvements of using primitives.

Therefore, specializing generics is to eliminate the need for these "hacks". Instead, the Java language strives to enable generic types for basically everything: object references, primitives, value types, and maybe even void.

Conclusion

We have a preliminary understanding of the changes that the Valhalla project will bring to the Java language. Two of the main goals are to improve performance and reduce leaky abstractions.

Performance enhancements are addressed by flattening the object graph and removing indirection. This results in a more efficient memory layout and fewer allocations and garbage collections.

When used as a generic type, primitives and objects have more similar behavior, which is a better abstraction.

Recommended study: "java video tutorial"

The above is the detailed content of Let's talk about the Java Valhalla Project. For more information, please follow other related articles on the PHP Chinese website!