Java:异步序列化对象到文件

Question

我正在制作一个 Minecraft 克隆，我有一个名为chunks的Map<Vector3i, Chunk>来存储所有加载的块。每一帧，这个循环运行：

for(Vector3i v:chunksToUnrender){
...
CompletableFuture.runAsync(() -> {
try {
chunks.get(v).toFile(new File(String.format("res-server/regions/%s.%s.%s.mcr", v.x, v.y, v.z)));
synchronized (chunksStateGuard) {
chunks.remove(v);
}
} catch(IOException e) {
e.printStackTrace();
System.err.println("Unable to save chunk " + Utils.format3i(v));
}
});
}

此处的目标是异步卸载块。Chunk.toFile(File)的内容是：

public void toFile(File file) throws IOException {
FileOutputStream fos = new FileOutputStream(file);
fos.write(SerializationUtils.serialize(this));
fos.flush();
fos.close();
}

然而，尽管使用了CompletableFuture，每当卸载一个块时，游戏都会在短时间内受到帧率打击，因为它会序列化和卸载块。有没有办法避免在后台任务工作时中断主线程？

Answer 1

如前面的评论中所述，您可以使用缓存进一步增强实现，该缓存可以优化序列化过程，同时提供更快的读取速度。

下面是一个示例代码，演示了使用 ehCache 设置和用法缓存。

Maven Dependency (in pom.xml)

<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.9.0</version>
</dependency>

ehCache Configuration (ehcache.xml)

注意 - 此文件应在类路径中可用。

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
monitoring="autodetect" dynamicConfig="true">
<!-- By default, Ehcache stored the cached files in temp folder. -->
<!-- <diskStore path="java.io.tmpdir" /> -->
<!-- Ask Ehcache to store cache in this path -->
<diskStore path="c:\temp\ehcache" />
<!-- Sample cache named cache1
This cache contains a maximum in memory of 10000 elements, and will expire
an element if it is idle for more than 5 minutes and lives for more than
10 minutes.
If there are more than 10000 elements it will overflow to the
disk cache, which in this configuration will go to wherever java.io.tmp is
defined on your system. On a standard Linux system this will be /tmp" -->
<cache name="ApplicationContentCache" 
maxEntriesLocalHeap="10000"
maxEntriesLocalDisk="1000" 
eternal="false" 
diskSpoolBufferSizeMB="20"
timeToIdleSeconds="300" timeToLiveSeconds="600"
memoryStoreEvictionPolicy="LFU" 
transactionalMode="off">
<persistence strategy="localTempSwap" />
</cache>
</ehcache>

各种 Java 类

import java.io.Serializable;
import java.util.concurrent.CompletableFuture;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
/**
* Demo class for the caching functionality
* @author Rahul R
*
*/
public class ApplicationCacheDemo {
public static void main(String... args) {
ApplicationCacheFactory cacheFactory = ApplicationCacheFactory.instance;
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
try (ApplicationCache<CachableObject> cache = cacheFactory.getApplicationCache()) {
CachableObject cacheContent = new CachableObject("A sample content");
int identity = cache.put(cacheContent);
CachableObject readContent = cache.get(identity);
System.out.println(readContent.getData());          
} catch (Exception e) {
e.printStackTrace();
}
});
future.join();
}
}
/**
* The class whose objects would be cached.
* @author Rahul R
*
*/
class CachableObject implements Serializable {
private static final long serialVersionUID = 1L;
private String data = null;
public CachableObject() {
super();
}
public CachableObject(String data) {
super();
setData(data);
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((data == null) ? 0 : data.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
CachableObject other = (CachableObject) obj;
if (data == null) {
if (other.data != null)
return false;
} else if (!data.equals(other.data))
return false;
return true;
}
@Override
public String toString() {
return "CachableObject [" + getData() + "]";
}
}
/**
* A singleton factory implemented through Enum
* @author Rahul R
*
*/
enum ApplicationCacheFactory {
instance;
public ApplicationCache<CachableObject> getApplicationCache() {
return new ApplicationCache<>("ApplicationContentCache");
}
}
/**
* A simplistic cache facade
* @author Rahul R
*
*/
class ApplicationCache<E> implements AutoCloseable {    
private CacheManager cm = null;
private String cacheName = null;
private Cache cache = null;
public ApplicationCache(String cacheName) {
super();
setCacheName(cacheName);
initializeCache();
}
private void initializeCache() {
cm = CacheManager.getInstance();
cache = cm.getCache(getCacheName());
}
public String getCacheName() {
return cacheName;
}
public void setCacheName(String cacheName) {
this.cacheName = cacheName;
}
public int put(E value) {
int identity = value.hashCode();
cache.put(new Element(identity, value));
return identity;
}
@SuppressWarnings("unchecked")
public E get(int identity) {
E result = null;
Element element = cache.get(identity);
if (element != null) {
result = (E) element.getObjectValue();
}
return result;
}
@Override
public void close() throws Exception {
cm.shutdown();
}
}

Answer 2

这是一个X-Y问题。问题是从文件同步加载块。