Вы когда-нибудь хотели бы превратить объект Java в поток байтов так быстро, как это можно сделать на родном языке, таком как C ++? Если вы используете стандартную сериализацию Java, вы можете быть разочарованы производительностью. Java Serialization была разработана для совершенно иной цели, чем сериализация объектов настолько быстро и компактно, насколько это возможно.
Зачем нам нужна быстрая и компактная сериализация? Многие из наших систем распределены, и нам нужно обмениваться информацией, эффективно передавая состояние между процессами. Это состояние живет внутри наших объектов. Я профилировал многие системы, и часто большая часть затрат заключается в сериализации этого состояния в байтовые буферы. Я видел значительный спектр протоколов и механизмов, используемых для достижения этой цели. На одном конце спектра находятся простые в использовании, но неэффективные протоколы, такие как Java
Serialization ,
XML и
JSON . На другом конце этого спектра находятся бинарные протоколы, которые могут быть очень быстрыми и эффективными, но они требуют более глубокого понимания и навыков.
В этой статье я проиллюстрирую прирост производительности, который возможен при использовании простых двоичных протоколов, и познакомлю вас с малоизвестной техникой, доступной в Java, для достижения производительности, аналогичной той, которая возможна с родными языками, такими как C или C ++.
Три подхода для сравнения:
- Сериализация Java : стандартный метод в Java для реализации объекта в Serializable .
- Двоичный через ByteBuffer : простой протокол, использующий API ByteBuffer для записи полей объекта в двоичном формате. Это наша основа для того, что считается хорошим подходом двоичного кодирования.
- Двоичные через Unsafe : Введение в Unsafe и его набор методов, которые позволяют напрямую манипулировать памятью. Здесь я покажу, как получить аналогичную производительность C / C ++.
Код
import sun.misc.Unsafe;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.util.Arrays;
public final class TestSerialisationPerf
{
public static final int REPETITIONS = 1 * 1000 * 1000;
private static ObjectToBeSerialised ITEM =
new ObjectToBeSerialised(
1010L, true, 777, 99,
new double[]{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0},
new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
public static void main(final String[] arg) throws Exception
{
for (final PerformanceTestCase testCase : testCases)
{
for (int i = 0; i < 5; i++)
{
testCase.performTest();
System.out.format("%d %s\twrite=%,dns read=%,dns total=%,dns\n",
i,
testCase.getName(),
testCase.getWriteTimeNanos(),
testCase.getReadTimeNanos(),
testCase.getWriteTimeNanos() +
testCase.getReadTimeNanos());
if (!ITEM.equals(testCase.getTestOutput()))
{
throw new IllegalStateException("Objects do not match");
}
System.gc();
Thread.sleep(3000);
}
}
}
private static final PerformanceTestCase[] testCases =
{
new PerformanceTestCase("Serialisation", REPETITIONS, ITEM)
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
public void testWrite(ObjectToBeSerialised item) throws Exception
{
for (int i = 0; i < REPETITIONS; i++)
{
baos.reset();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(item);
oos.close();
}
}
public ObjectToBeSerialised testRead() throws Exception
{
ObjectToBeSerialised object = null;
for (int i = 0; i < REPETITIONS; i++)
{
ByteArrayInputStream bais =
new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
object = (ObjectToBeSerialised)ois.readObject();
}
return object;
}
},
new PerformanceTestCase("ByteBuffer", REPETITIONS, ITEM)
{
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
public void testWrite(ObjectToBeSerialised item) throws Exception
{
for (int i = 0; i < REPETITIONS; i++)
{
byteBuffer.clear();
item.write(byteBuffer);
}
}
public ObjectToBeSerialised testRead() throws Exception
{
ObjectToBeSerialised object = null;
for (int i = 0; i < REPETITIONS; i++)
{
byteBuffer.flip();
object = ObjectToBeSerialised.read(byteBuffer);
}
return object;
}
},
new PerformanceTestCase("UnsafeMemory", REPETITIONS, ITEM)
{
UnsafeMemory buffer = new UnsafeMemory(new byte[1024]);
public void testWrite(ObjectToBeSerialised item) throws Exception
{
for (int i = 0; i < REPETITIONS; i++)
{
buffer.reset();
item.write(buffer);
}
}
public ObjectToBeSerialised testRead() throws Exception
{
ObjectToBeSerialised object = null;
for (int i = 0; i < REPETITIONS; i++)
{
buffer.reset();
object = ObjectToBeSerialised.read(buffer);
}
return object;
}
},
};
}
abstract class PerformanceTestCase
{
private final String name;
private final int repetitions;
private final ObjectToBeSerialised testInput;
private ObjectToBeSerialised testOutput;
private long writeTimeNanos;
private long readTimeNanos;
public PerformanceTestCase(final String name, final int repetitions,
final ObjectToBeSerialised testInput)
{
this.name = name;
this.repetitions = repetitions;
this.testInput = testInput;
}
public String getName()
{
return name;
}
public ObjectToBeSerialised getTestOutput()
{
return testOutput;
}
public long getWriteTimeNanos()
{
return writeTimeNanos;
}
public long getReadTimeNanos()
{
return readTimeNanos;
}
public void performTest() throws Exception
{
final long startWriteNanos = System.nanoTime();
testWrite(testInput);
writeTimeNanos = (System.nanoTime() - startWriteNanos) / repetitions;
final long startReadNanos = System.nanoTime();
testOutput = testRead();
readTimeNanos = (System.nanoTime() - startReadNanos) / repetitions;
}
public abstract void testWrite(ObjectToBeSerialised item) throws Exception;
public abstract ObjectToBeSerialised testRead() throws Exception;
}
class ObjectToBeSerialised implements Serializable
{
private static final long serialVersionUID = 10275539472837495L;
private final long sourceId;
private final boolean special;
private final int orderCode;
private final int priority;
private final double[] prices;
private final long[] quantities;
public ObjectToBeSerialised(final long sourceId, final boolean special,
final int orderCode, final int priority,
final double[] prices, final long[] quantities)
{
this.sourceId = sourceId;
this.special = special;
this.orderCode = orderCode;
this.priority = priority;
this.prices = prices;
this.quantities = quantities;
}
public void write(final ByteBuffer byteBuffer)
{
byteBuffer.putLong(sourceId);
byteBuffer.put((byte)(special ? 1 : 0));
byteBuffer.putInt(orderCode);
byteBuffer.putInt(priority);
byteBuffer.putInt(prices.length);
for (final double price : prices)
{
byteBuffer.putDouble(price);
}
byteBuffer.putInt(quantities.length);
for (final long quantity : quantities)
{
byteBuffer.putLong(quantity);
}
}
public static ObjectToBeSerialised read(final ByteBuffer byteBuffer)
{
final long sourceId = byteBuffer.getLong();
final boolean special = 0 != byteBuffer.get();
final int orderCode = byteBuffer.getInt();
final int priority = byteBuffer.getInt();
final int pricesSize = byteBuffer.getInt();
final double[] prices = new double[pricesSize];
for (int i = 0; i < pricesSize; i++)
{
prices[i] = byteBuffer.getDouble();
}
final int quantitiesSize = byteBuffer.getInt();
final long[] quantities = new long[quantitiesSize];
for (int i = 0; i < quantitiesSize; i++)
{
quantities[i] = byteBuffer.getLong();
}
return new ObjectToBeSerialised(sourceId, special, orderCode,
priority, prices, quantities);
}
public void write(final UnsafeMemory buffer)
{
buffer.putLong(sourceId);
buffer.putBoolean(special);
buffer.putInt(orderCode);
buffer.putInt(priority);
buffer.putDoubleArray(prices);
buffer.putLongArray(quantities);
}
public static ObjectToBeSerialised read(final UnsafeMemory buffer)
{
final long sourceId = buffer.getLong();
final boolean special = buffer.getBoolean();
final int orderCode = buffer.getInt();
final int priority = buffer.getInt();
final double[] prices = buffer.getDoubleArray();
final long[] quantities = buffer.getLongArray();
return new ObjectToBeSerialised(sourceId, special, orderCode,
priority, prices, quantities);
}
@Override
public boolean equals(final Object o)
{
if (this == o)
{
return true;
}
if (o == null || getClass() != o.getClass())
{
return false;
}
final ObjectToBeSerialised that = (ObjectToBeSerialised)o;
if (orderCode != that.orderCode)
{
return false;
}
if (priority != that.priority)
{
return false;
}
if (sourceId != that.sourceId)
{
return false;
}
if (special != that.special)
{
return false;
}
if (!Arrays.equals(prices, that.prices))
{
return false;
}
if (!Arrays.equals(quantities, that.quantities))
{
return false;
}
return true;
}
}
class UnsafeMemory
{
private static final Unsafe unsafe;
static
{
try
{
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe)field.get(null);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
private static final long byteArrayOffset = unsafe.arrayBaseOffset(byte[].class);
private static final long longArrayOffset = unsafe.arrayBaseOffset(long[].class);
private static final long doubleArrayOffset = unsafe.arrayBaseOffset(double[].class);
private static final int SIZE_OF_BOOLEAN = 1;
private static final int SIZE_OF_INT = 4;
private static final int SIZE_OF_LONG = 8;
private int pos = 0;
private final byte[] buffer;
public UnsafeMemory(final byte[] buffer)
{
if (null == buffer)
{
throw new NullPointerException("buffer cannot be null");
}
this.buffer = buffer;
}
public void reset()
{
this.pos = 0;
}
public void putBoolean(final boolean value)
{
unsafe.putBoolean(buffer, byteArrayOffset + pos, value);
pos += SIZE_OF_BOOLEAN;
}
public boolean getBoolean()
{
boolean value = unsafe.getBoolean(buffer, byteArrayOffset + pos);
pos += SIZE_OF_BOOLEAN;
return value;
}
public void putInt(final int value)
{
unsafe.putInt(buffer, byteArrayOffset + pos, value);
pos += SIZE_OF_INT;
}
public int getInt()
{
int value = unsafe.getInt(buffer, byteArrayOffset + pos);
pos += SIZE_OF_INT;
return value;
}
public void putLong(final long value)
{
unsafe.putLong(buffer, byteArrayOffset + pos, value);
pos += SIZE_OF_LONG;
}
public long getLong()
{
long value = unsafe.getLong(buffer, byteArrayOffset + pos);
pos += SIZE_OF_LONG;
return value;
}
public void putLongArray(final long[] values)
{
putInt(values.length);
long bytesToCopy = values.length << 3;
unsafe.copyMemory(values, longArrayOffset,
buffer, byteArrayOffset + pos,
bytesToCopy);
pos += bytesToCopy;
}
public long[] getLongArray()
{
int arraySize = getInt();
long[] values = new long[arraySize];
long bytesToCopy = values.length << 3;
unsafe.copyMemory(buffer, byteArrayOffset + pos,
values, longArrayOffset,
bytesToCopy);
pos += bytesToCopy;
return values;
}
public void putDoubleArray(final double[] values)
{
putInt(values.length);
long bytesToCopy = values.length << 3;
unsafe.copyMemory(values, doubleArrayOffset,
buffer, byteArrayOffset + pos,
bytesToCopy);
pos += bytesToCopy;
}
public double[] getDoubleArray()
{
int arraySize = getInt();
double[] values = new double[arraySize];
long bytesToCopy = values.length << 3;
unsafe.copyMemory(buffer, byteArrayOffset + pos,
values, doubleArrayOffset,
bytesToCopy);
pos += bytesToCopy;
return values;
}
}
Полученные результаты
2.8GHz Nehalem - Java 1.7.0_04 ============================== 0 Serialisation write=2,517ns read=11,570ns total=14,087ns 1 Serialisation write=2,198ns read=11,122ns total=13,320ns 2 Serialisation write=2,190ns read=11,011ns total=13,201ns 3 Serialisation write=2,221ns read=10,972ns total=13,193ns 4 Serialisation write=2,187ns read=10,817ns total=13,004ns 0 ByteBuffer write=264ns read=273ns total=537ns 1 ByteBuffer write=248ns read=243ns total=491ns 2 ByteBuffer write=262ns read=243ns total=505ns 3 ByteBuffer write=300ns read=240ns total=540ns 4 ByteBuffer write=247ns read=243ns total=490ns 0 UnsafeMemory write=99ns read=84ns total=183ns 1 UnsafeMemory write=53ns read=82ns total=135ns 2 UnsafeMemory write=63ns read=66ns total=129ns 3 UnsafeMemory write=46ns read=63ns total=109ns 4 UnsafeMemory write=48ns read=58ns total=106ns 2.4GHz Sandy Bridge - Java 1.7.0_04 =================================== 0 Serialisation write=1,940ns read=9,006ns total=10,946ns 1 Serialisation write=1,674ns read=8,567ns total=10,241ns 2 Serialisation write=1,666ns read=8,680ns total=10,346ns 3 Serialisation write=1,666ns read=8,623ns total=10,289ns 4 Serialisation write=1,715ns read=8,586ns total=10,301ns 0 ByteBuffer write=199ns read=198ns total=397ns 1 ByteBuffer write=176ns read=178ns total=354ns 2 ByteBuffer write=174ns read=174ns total=348ns 3 ByteBuffer write=172ns read=183ns total=355ns 4 ByteBuffer write=174ns read=180ns total=354ns 0 UnsafeMemory write=38ns read=75ns total=113ns 1 UnsafeMemory write=26ns read=52ns total=78ns 2 UnsafeMemory write=26ns read=51ns total=77ns 3 UnsafeMemory write=25ns read=51ns total=76ns 4 UnsafeMemory write=27ns read=50ns total=77ns
Анализ
Для записи и считывания одного относительно небольшого объекта на моем быстром ноутбуке с процессором Sandy Bridge с частотой 2,4 ГГц может потребоваться ~ 10000 нс при использовании сериализации Java, тогда как при использовании Unsafe это может доходить до менее 100 нс даже с учетом самого тестового кода. Чтобы поместить это в контекст, при использовании Java Serialization затраты равны сетевому переходу! Теперь это будет очень дорого, если ваш транспорт — это быстрыймеханизм IPC в той же системе.
Существует множество причин, по которым Java-сериализация стоит так дорого. Например, он записывает полные имена классов и полей для каждого объекта, а также информацию о версии. Также ObjectOutputStream хранит коллекцию всех записанных объектов, чтобы их можно было сопоставлять при закрытии ().называется. Сериализация Java требует 340 байтов для этого примера объекта, но нам требуется только 185 байтов для двоичных версий. Подробности о формате сериализации Java можно найти здесь . Если бы я не использовал массивы для большинства данных, то сериализованный объект был бы значительно больше с сериализацией Java из-за имен полей. По моему опыту текстовые протоколы, такие как XML и JSON, могут быть даже менее эффективными, чем сериализация Java. Также имейте в виду, что Java Serialization является стандартным механизмом, используемым для RMI .
Настоящая проблема заключается в количестве выполняемых инструкций. Небезопасный метод выигрывает со значительным преимуществом, потому что в Hotspot и многих других JVM оптимизатор рассматривает эти операции как внутренние и заменяет вызов инструкциями по сборке для выполнения манипуляций с памятью. Для примитивных типов это приводит к одной инструкции x86 MOV, которая часто может происходить за один цикл. Детали можно увидеть, если Hotspot выведет оптимизированный код, как я описал в предыдущей статье .
Теперь нужно сказать, что « с большой силой приходит большая ответственность », и если вы используете Unsafe, это фактически то же самое, что программирование на C, и с этим могут происходить нарушения доступа к памяти, когда вы получаете неправильные смещения.
Добавление некоторого контекста
«Как насчет подобных буферов протокола Google ?», Я слышу, как вы кричите. Это очень полезные библиотеки, которые часто предлагают лучшую производительность и большую гибкость, чем сериализация Java. Тем не менее, они не очень близко к производительности использования Unsafe, как я показал здесь. Протоколные буферы решают другую проблему и предоставляют хорошие сообщения с самоописанием, которые хорошо работают на разных языках. Пожалуйста, протестируйте с различными протоколами и методами сериализации, чтобы сравнить результаты.
Также проницательный среди вас будет спрашивать: «А как насчет порядка байтов написанных целых чисел?» С небезопаснымбайты записаны в собственном порядке. Это отлично подходит для IPC и между системами одного типа. Когда системы используют разные форматы, тогда потребуется преобразование.
Как мы имеем дело с несколькими версиями класса или определяем, к какому классу принадлежит объект? Я хочу сосредоточить внимание на этой статье, но, скажем, простое целое число, указывающее, что класс реализации — это все, что требуется для заголовка. Это целое число может использоваться для поиска соответствующей реализации для операции десериализации.
Аргумент, который я часто слышу против двоичных протоколов и текстовых протоколов, это как насчет того, чтобы быть читаемым человеком и отлаженным? Существует простое решение для этого. Разработайте инструмент для чтения двоичного формата!
Вывод
В заключение можно достичь тех же самых родных C / C ++ уровней производительности в Java для сериализации объекта в поток байтов и из него, эффективно используя те же методы. Класс UnsafeMemory , для которого я предоставил каркасную реализацию, можно легко расширить, чтобы инкапсулировать это поведение и таким образом защитить себя от многих потенциальных проблем при работе с таким острым инструментом.
Теперь для насущного вопроса. Не было бы намного лучше, если бы Java предложила альтернативный интерфейс Marshallable к Serializable , предлагая изначально то, что я эффективно сделал с Unsafe ???