Java：从Java 8开始受益于内联类属性

最新推荐文章于 2022-07-01 16:40:09 发布

dnc8371

最新推荐文章于 2022-07-01 16:40:09 发布

阅读量209

点赞数

文章标签：数据库 java python 大数据编程语言

希望在几年内，Java将具有“内联类”功能，该功能可以解决Java当前状态下的许多挑战。阅读本文并学习如何立即使用Java 8或更高版本，并且仍将受益于即将出现的内联对象数组的一些优点，例如；没有间接指针，消除了对象标头开销，并改善了数据局部性。

在本文中，我们将学习如何编写一个名为
InlineArray支持将来的许多内联类功能。我们还将看一下Speedment HyperStream，这是一个使用类似操作方法的现有Java工具。

背景

自1995年以来，当从完全合理的角度出发时，Java中的Objects数组由一个数组组成，该数组又包含对其他对象的大量引用，这些引用最终分散在堆中。

现在，这是在Java中将具有两个初始Point对象的数组布置在堆上的方式：

 Array  +======+  |Header|  +------+     Point 0  |ref 0 |---> +======+  +------+    |Header|      Point +------+    |Header|      Point 1  |ref 1 |---- +------+ ---> +======+  +------+    |x    |     |Header|  | null |    +------+     +------+ |    +------+     +------+  +------+    |y    |     |x    |  | null |    +------+     +------+ |    +------+     +------+  +------+                  |y    |  |...  |                  +------+  +------+

但是，随着时间的流逝，典型的CPU的执行流水线已经发生了巨大的变化，并且计算性能得到了惊人的提高。另一方面，光速保持恒定，因此，不幸的是，从主存储器加载数据的等待时间保持在相同的数量级内。计算和检索之间的平衡已偏向于计算。

这些天来访问主内存已成为我们要避免的事情，就像我们希望避免过去从旋转磁盘中加载数据一样。

显然，当前的Object数组布局具有几个缺点，例如：

双内存访问（由于数组中的间接引用指针）
数据局部性降低（因为数组对象放置在堆中的不同位置）
增加的内存占用量（因为数组中引用的所有对象都是对象，因此拥有附加的Class和同步信息）。

内联类

在Java社区内，现在正在付出很大的努力来引入“内联类”（以前称为“值类”）。这项工作的最新状态（截至2019年7月）由Brian Goetz i提出。
在此视频中，标题为“ Project Valhalla Update（2019版）”。没有人知道何时在正式的Java版本中提供此功能。我个人的猜测是2021年以后的某个时候。

一旦此功能可用，以下是如何排列嵌入式Point对象的数组：

 Array  +======+  |Header|  +------+  |x    |  +------+  |y    |  +------+  |x    |  +------+  |y    |  +------+  |...  |  +------+

可以看出，该方案消耗更少的内存（没有Point头），提高了局部性（数据按顺序放置在内存中），并且可以直接访问数据而无需遵循间接引用指针。另一方面，我们丢失了对象身份的概念，本文稍后将对此进行讨论。

模拟一些内联类属性

在下面，我们将对内联类的某些属性进行仿真。应当注意，下面的所有示例现在都可以在标准Java 8和更高版本上运行。

假设我们有一个interface Point带有X和Y吸气剂，如下所述：

 public interface Point { int x(); int y(); } y(); }

然后，我们可以轻松地创建一个不变的实现
Point界面如下图所示：

 public final class VanillaPoint implements Point { 
     private final int x, y; 
     public VanillaPoint( int x, int y) { 
         this .x = x; 
         this .y = y; 
     } 
     @Override public int x() { return x; } x; } 
     @Override public int y() { return y; } y; } 
     // toString(), equals() and hashCode() not shown for brevity  }

此外，假设我们愿意放弃数组中Point对象的Object / identity属性。这意味着，除其他外，我们无法同步或执行身份操作（例如==和System::identityHashCode ）

这里的想法是创建一个内存区域，我们可以直接在字节级别使用该内存区域，并在那里将对象展平。可以将这个内存区域封装在一个名为InlineArray<T>的通用类中，如下所示：

 public final class InlineArray<T> { 
     private final ByteBuffer memoryRegion; 
     private final int elementSize; 
     private final int length; 
     private final BiConsumer<ByteBuffer, T> deconstructor; 
     private final Function<ByteBuffer,T> constructor; 
     private final BitSet presentFlags; 
     public InlineArray( 
         int elementSize, 
         int length, 
         BiConsumer<ByteBuffer, T> deconstructor, 
         Function<ByteBuffer,T> constructor 
     ) { 
         this .elementSize = elementSize; 
         this .length = length; 
         this .deconstructor = requireNonNull(deconstructor); 
         this .constructor = requireNonNull(constructor); 
         this .memoryRegion = ByteBuffer.allocateDirect(elementSize * length); 
         this .presentFlags = new BitSet(length); 
     } 
     public void put( int index, T value) { 
         assertIndexBounds(index); 
         if (value == null ) { 
             presentFlags.clear(index); 
         } else { 
             position(index); 
             deconstructor.accept(memoryRegion, value); 
             presentFlags.set(index); 
         } 
     } 
     public T get( int index) { 
         assertIndexBounds(index); 
         if (!presentFlags.get(index)) { 
             return null ; 
         } 
         position(index); 
         return constructor.apply(memoryRegion); 
     } 
     public int length() { 
         return length; 
     } 
     private void assertIndexBounds( int index) { 
         if (index < 0 || index >= length) { 
             throw new IndexOutOfBoundsException( "Index [0, " + length + "), was:" + index); 
         } 
     } 
     private void position( int index) { 
         memoryRegion.position(index * elementSize); 
     }  }

请注意，此类可以处理任何类型的元素（ T类型），但前提是它具有最大的元素大小，但可以将其解构（序列化）为字节。如果所有元素的元素大小都与Point相同，则该类效率最高（即始终为Integer.BYTES * 2 = 8字节）。还要注意，该类不是线程安全的，但是可以添加该类以增加内存屏障为代价，并且根据解决方案使用ByteBuffer单独视图。

现在，假设我们要分配一万个点的数组。有了新的InlineArray类，我们可以这样进行：

 public class Main { 
     public static void main(String[] args) { 
         InlineArray<Point> pointArray = new InlineArray<>( 
             Integer.BYTES * 2 , // The max element size 
             10_000, 
             (bb, p) -> {bb.putInt(px()); bb.putInt(py());}, 
             bb -> new VanillaPoint(bb.getInt(), bb.getInt()) 
         ); 
         Point p0 = new VanillaPoint( 0 , 0 ); 
         Point p1 = new VanillaPoint( 1 , 1 ); 
         pointArray.put( 0 , p0); // Store p0 at index 0 
         pointArray.put( 1 , p1); // Store p1 at index 1 
         System.out.println(pointArray.get( 0 )); // Should produce (0, 0) 
         System.out.println(pointArray.get( 1 )); // Should produce (1, 1) 
         System.out.println(pointArray.get( 2 )); // Should produce null 
     }  }

如预期的那样，代码在运行时将产生以下输出：

 VanillaPoint{x= 0 , y= 0 }  VanillaPoint{x= 1 , y= 1 }  null

请注意，我们如何向InlineArray提供元素解构函数和元素构造函数，以告知其应如何解构和构造
Point对象指向线性存储器或从线性存储器Point对象。

仿真属性

上面的模拟可能不会获得与真正的内联类相同的性能提升，但是在内存分配和位置方面的节省将是大致相同的。上面的模拟是分配堆外内存，因此您的垃圾回收时间将不受InlineArray放置的元素数据的InlineArray 。 ByteBuffer中的元素的布局就像建议的内联类数组一样：

 Array  +======+  |Header|  +------+  |x    |  +------+  |y    |  +------+  |x    |  +------+  |y    |  +------+  |...  |  +------+

由于我们使用ByteBuffer被索引与对象
int ，后备存储区域被限制为2 ^ 31个字节。例如，这意味着我们只能将2 ^（31-3）= 2 ^ 28≈2.68亿在我们用尽地址空间之前，数组中的Point元素（因为每个点占用2 ^ 3 = 8个字节）。实际的实现可以通过使用多个ByteBuffer，Unsafe或Chronicle Bytes之类的库来克服此限制。

懒惰的实体

给定InlineArray类，从中提供元素非常容易
InlineArray是惰性的，在某种意义上，当从数组中检索元素时，它们不必急于反序列化所有字段。这是可以做到的：

首先，我们创建Point接口的另一种实现，该实现从后备ByteBuffer本身而不是本地字段中获取其数据：

 public final class LazyPoint implements Point { 
     private final ByteBuffer byteBuffer; 
     private final int position; 
     public LazyPoint(ByteBuffer byteBuffer) { 
         this .byteBuffer = byteBuffer; 
         this .position = byteBuffer.position(); 
     } 
     @Override 
     public int x() { 
         return byteBuffer.getInt(position); 
     } 
     @Override 
     public int y() { 
         return byteBuffer.getInt(position + Integer.BYTES); 
     } 
     // toString(), equals() and hashCode() not shown for brevity  }

然后，我们只需要替换粘贴到
InlineArray是这样的：

 InlineArray pointArray = new InlineArray<>( 
     Integer.BYTES * 2 , 
     10_000, 
     (bb, p) -> {bb.putInt(px()); bb.putInt(py());}, 
     LazyPoint:: new // Use this deserializer instead  );

如果使用与上述相同的主要方法，将产生以下输出：

 LazyPoint{x= 0 , y= 0 }  LazyPoint{x= 1 , y= 1 }  null

凉。这对于具有数十个甚至数百个字段的实体特别有用，因为对于其中的问题，只能访问字段的有限子集。

这种方法的缺点是，如果在我们的应用程序中仅保留一个LazyPoint引用，则它将阻止整个后备ByteBuffer垃圾回收。因此，像这样的任何惰性实体都最好用作短期对象。

使用大量数据

如果我们想使用非常大的数据集合（例如，以TB为单位），可能来自数据库或文件，并将其有效地存储在JVM内存中，然后能够使用这些集合来提高计算性能，该怎么办？我们可以使用这种技术吗？

Speedment HyperStream是一种利用类似技术能够将数据库数据作为标准Java Streams提供的产品，并且已经有一段时间了。 HyperStream可以按上述方式布置数据，并且可以在单个JVM中存储TB级的数据，而对Garbage Collection的影响很小或没有影响，因为数据是非堆存储的。它可以使用就地反序列化直接从后备存储区域中获得单个字段，从而避免了不必要的实体完全反序列化。它的标准Java流是确定性的超低延迟，在某些情况下可以在100 ns内构造和使用流。

这是在电影之间进行分页时如何在应用程序中使用HyperStream（实现标准Java Stream）的示例。的
Manager films变量由Speedment自动提供：

 private Stream<Film> getPage( int page, Comparator<Film> comparator) { 
     return films.stream() 
         .sorted(comparator) 
         .skip(page * PAGE_SIZE) 
         .limit(PAGE_SIZE) 
     }

即使可能有数万亿的影片，该方法通常也将在不到一微秒的时间内完成，因为Stream直接连接到RAM并使用内存索引。

在此处阅读有关Speedment HyperStream性能的更多信息。

通过在此处下载Speedment HyperStream 来评估自己的数据库应用程序中的性能。