引言
1. Android性能优化篇之内存优化--内存泄漏
2.Android性能优化篇之内存优化--内存优化分析工具
3.Android性能优化篇之UI渲染性能优化
4.Android性能优化篇之计算性能优化
5.Android性能优化篇之电量优化(1)——电量消耗分析
6.Android性能优化篇之电量优化(2)
7.Android性能优化篇之网络优化
8.Android性能优化篇之Bitmap优化
9.Android性能优化篇之图片压缩优化
10.Android性能优化篇之多线程并发优化
11.Android性能优化篇之数据传输效率优化
12.Android性能优化篇之程序启动时间性能优化
13.Android性能优化篇之安装包性能优化
14.Android性能优化篇之服务优化
介绍
数据的序列化是程序代码里面必不可少的组成部分,这篇我们就来一起看看序列化相关的知识。
数据序列化的行为可能发生在数据传递过程中的任何阶段,例如网络传输,不同进程间数据传递,不同类之间的参数传递,把数据存储到磁盘上等等。
什么是序列化和反序列化?
简单来说就是将对象转换为可以传输的二进制流(二进制序列)的过程,这样我们就可以通过序列化,转化为可以在网络传输或者保存到本地的流(序列),从而进行传输数据 ,那反序列化就是从二进制流(序列)转化为对象的过程.
常用的序列化有哪几种?
(1).Serializable
Serializable是我们平时使用比较多的,但是这种传统的做法效率不高,实施的过程会消耗更多的内存。
使用
public class CompanyInfo implements Serializable {
序列化
out = new FileOutputStream(mSerializeFile);
CompanyInfo companyInfo = new CompanyInfo(1001, "常州网络有限公司");
objectOutputStream = new ObjectOutputStream(out);
objectOutputStream.writeObject(companyInfo);
反序列化
fIn = new FileInputStream(mSerializeFile);
objectInputStream = new ObjectInputStream(fIn);
Object object
= objectInputStream.readObject();
if(object instanceof CompanyInfo){
CompanyInfo info = (CompanyInfo) object;
}
(2).Parcelable
Parcelable是Android为我们提供的序列化的接口,Parcelable相对于Serializable的使用相对复杂一些,但Parcelable的效率相对Serializable也高很多
使用
public class PersonInfo implements Parcelable
序列化
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(id);
dest.writeString(name);
dest.writeString(love);
}
反序列化
protected PersonInfo(Parcel in) {
id = in.readInt();
name = in.readString();
love = in.readString();
}
public static final Creator CREATOR = new Creator() {
@Override
public PersonInfo createFromParcel(Parcel in) {
return new PersonInfo(in);
}
@Override
public PersonInfo[] newArray(int size) {
return new PersonInfo[size];
}
};
(3).Gson
GSON库来处理这个序列化的问题,不仅仅执行速度更快,内存的使用效率也更高。
下面介绍三个数据序列化的候选方案:
- Protocal Buffers:强大,灵活,但是对内存的消耗会比较大,并不是移动终端上的最佳选择。
- Nano-Proto-Buffers:基于Protocal,为移动终端做了特殊的优化,代码执行效率更高,内存使用效率更佳。
FlatBuffers:这个开源库最开始是由Google研发的,专注于提供更优秀的性能。
上面这些方案在性能方面的数据对比如下图所示:
FlatBuffers 几乎从空间和时间复杂度上完胜其他技术。
FlatBuffers 是一个开源的跨平台数据序列化库,可以应用到几乎任何语言(C++, C#, Go, Java, JavaScript, PHP, Python),最开始是 Google 为游戏或者其他对性能要求很高的应用开发的。
FlatBuffers
1.FlatBuffers优点
(1).直接读取序列化数据,而不需要解析(Parsing)或者解包(Unpacking):FlatBuffer 把数据层级结构保存在一个扁平化的二进制缓存(一维数组)中,同时能够保持直接获取里面的结构化数据,而不需要解析,并且还能保证数据结构变化的前后向兼容。
(2).高效的内存使用和速度:FlatBuffer 使用过程中,不需要额外的内存,几乎接近原始数据在内存中的大小。
(3).灵活:数据能够前后向兼容,并且能够灵活控制你的数据结构。
(4).很少的代码侵入性:使用少量的自动生成的代码即可实现。
(5).强数据类性,易于使用,跨平台,几乎语言无关。
官方提供了一个性能对比表
在做 Android 开发的时候,JSON 是最常用的数据序列化技术。我们知道,JSON 的可读性很强,但是序列化和反序列化性能却是最差的。解析的时候,JSON 解析器首先,需要在内存中初始化一个对应的数据结构,这个事件经常会消耗 100ms ~ 200ms2;解析过程中,要产生大量的临时变量,造成 Java 虚拟机的 GC 和内存抖动,解析 20KB 的数据,大概会消耗 100KB 的临时内存2。FlatBuffers 就解决了这些问题。
2.FlatBuffers缺点
(1).FlatBuffers 需要生成代码,对代码有侵入性
(2).数据序列化没有可读性,不方便 Debug;
(3).构建 FlatBuffers 对象比较麻烦,不直观,特别是如果对象比较复杂情况下需要写大段的代码;
(4).数据的所有内容需要使用 Schema 严格定义,灵活性不如 JSON。
3.FlatBuffers原理
官方文档的介绍,FlatBuffers 就像它的名字所表示的一样,就是把结构化的对象,用一个扁平化(Flat)的缓冲区保存,简单的来说就是把内存对象数据,保存在一个一维的数组中。借用 Facebook 文章2的一张图如下:
可见,FlatBuffers 保存在一个 byte 数组中,有一个“支点”指针(pivot point)以此为界,存储的内容分为两个部分:元数据和数据内容。其中元数据部分就是数据在前面,其长度等于对象中的字段数量,每个 byte 保存对应字段内容在数组中的索引(从支点位置开始计算)。
如图,上面的 Person 对象第一个字段是 name,其值的索引位置是 1,所以从索引位置 1 开始的字符串,就是 name 字段的值 "John"。第二个字段是 friendshipStatus,其索引值是 6,找到值为 2, 表示 NotFriend。第三个字段是 spouse,也一个 Person 对象,索引值是 12,指向的是此对象的支点位置。第四个字段是一个数组,图中表示的数组为空,所以索引值是 0。通过上面的解析,可以看出,FlatBuffers 通过自己分配和管理对象的存储,使对象在内存中就是线性结构化的,直接可以把内存内容保存或者发送出去,加载“解析”数据只需要把 byte 数组加载到内存中即可,不需要任何解析,也不产生任何中间变量。
它与具体的机器或者运行环境无关,例如在 Java 中,对象内的内存不依赖 Java 虚拟机的堆内存分配策略实现,所以也是跨平台的。
4.FlatBuffers使用步骤:
(1).定义数据结构 Schema
namespace Character;
table Items{
items:[Basic];
itemId:long;
timestemp:long;
}
table Basic{
id:long;
name:string;
email:string;
code:long;
isVip:bool;
count:int;
headUrl:string (deprecated);
carList:[Car];
}
table Car{
id:long;
number:long;
describle:string;
}
root_type Items;
(2).把 Schema 编译成 Java
flatc.exe -j -b Character.fbs
(3).把生成的文件复制到项目中
(4).编写代码
序列化
FlatBufferBuilder builder = new FlatBufferBuilder();
int car1 = Car.createCar(builder, 1000l, 8000l, builder.createString("1000的描述"));
int car2 = Car.createCar(builder, 1001l, 8001l, builder.createString("1001的描述"));
int car3 = Car.createCar(builder, 1002l, 8002l, builder.createString("1002的描述"));
int basic1 = Basic.createBasic(builder, 2000,
builder.createString("2000产品"), true,
Basic.createCarListVector(builder, new int[]{car1, car2, car3}));
int basic2 = Basic.createBasic(builder, 2001,
builder.createString("2001产品"), true,
Basic.createCarListVector(builder, new int[]{car2, car3}));
int itemListId = Items.createItemListVector(builder, new int[]{basic1, basic2});
Items.startItems(builder);
Items.addItemList(builder,itemListId);
Items.addTimestemp(builder,2017l);
int endItems = Items.endItems(builder);
Items.finishItemsBuffer(builder,endItems);
FileOutputStream out = null;
FileChannel inChannel = null;
try{
if(mSerializeFile.exists()){
mSerializeFile.delete();
}
out = new FileOutputStream(mSerializeFile);
inChannel = out.getChannel();
ByteBuffer buffer =
builder.dataBuffer();
while (buffer.hasRemaining()) {
inChannel.write(buffer);
}
Toast.makeText(this,"序列号成功",Toast.LENGTH_LONG).show();
}
反序列化
in = new FileInputStream(mSerializeFile);
outChannel = in.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int readSize = 0;
while((readSize= outChannel.read(buffer))!=-1){
Log.e(TAG,"===>"+readSize);
}
buffer.flip();
Items rootAsItems = Items.getRootAsItems(buffer);
Log.e(TAG , "timestem ==>"+rootAsItems.timestemp());
int itemsLength
= rootAsItems.itemListLength();
for (int i = 0; i < itemsLength; i++) {
Basic basic = rootAsItems.itemList(i);
Log.e(TAG,"---id:"+basic.id()+"---name:"+basic.name());
int carListLength = basic.carListLength();
for (int i1 = 0; i1 < carListLength; i1++) {
Car car = basic.carList(i1);
Log.e(TAG,"-------------id:"+car.id()+"---describle:"+car.describle());
}
}
Toast.makeText(this,"序列号成功",Toast.LENGTH_LONG).show();
}
5.FlatBuffers使用建议:
(1).项目中有大量数据传输和解析,使用 JSON 成为了性能瓶颈时使用FlatBuffers
(2).稳定的数据结构定义,可以使用FlatBuffers