【发布时间】：2012-04-10 15:53:36
【问题描述】：
(Sometimes我们的主机错了；纳秒很重要；)
我有一个 Python Twisted 服务器，它与一些 Java 服务器对话，并且分析显示它在 JSON 编码器/解码器中花费了大约 30% 的运行时间；它的工作是每秒处理数千条消息。
This talk by youtube 提出了有趣的适用点：
序列化格式——不管你用哪一种，都是 昂贵的。措施。不要用泡菜。不是一个好的选择。成立 协议缓冲区慢。他们编写了自己的 BSON 实现 比您可以下载的快 10-15 倍。
你必须测量。 Vitess 将其协议换成了 HTTP 执行。即使它在 C 中，它也很慢。所以他们撕了 退出 HTTP 并使用 python 进行直接套接字调用，这是 8% 在全球 CPU 上更便宜。 HTTP 的封装非常昂贵。
测量。在 Python 中，测量就像阅读茶叶。 Python中有很多反直觉的东西，比如 抢夺收集的成本。他们的大部分应用程序都会花费 他们的时间序列化。分析序列化非常依赖于 您要输入的内容。序列化 int 与 序列化大 blob。
无论如何，我控制消息传递 API 的 Python 和 Java 端，并且可以选择与 JSON 不同的序列化。
我的消息如下所示：
- 可变数量的多头； 1 到 10K 之间的任何地方
- 和两个已经是UTF8的文本字符串；都在 1 到 3KB 之间
因为我是从套接字读取它们，所以我想要能够优雅地处理流的库 - 例如，如果它不告诉我它消耗了多少缓冲区，那会很烦人。
这个流的另一端当然是 Java 服务器；我不想选择对 Python 端很好但将问题转移到 Java 端的东西，例如性能或痛苦或脆弱的 API。
我显然会做我自己的分析。我在这里问是希望您描述我不会想到的方法，例如使用struct 以及最快的字符串/缓冲区是什么。
一些简单的测试代码给出了令人惊讶的结果：
import time, random, struct, json, sys, pickle, cPickle, marshal, array
def encode_json_1(*args):
return json.dumps(args)
def encode_json_2(longs,str1,str2):
return json.dumps({"longs":longs,"str1":str1,"str2":str2})
def encode_pickle(*args):
return pickle.dumps(args)
def encode_cPickle(*args):
return cPickle.dumps(args)
def encode_marshal(*args):
return marshal.dumps(args)
def encode_struct_1(longs,str1,str2):
return struct.pack(">iii%dq"%len(longs),len(longs),len(str1),len(str2),*longs)+str1+str2
def decode_struct_1(s):
i, j, k = struct.unpack(">iii",s[:12])
assert len(s) == 3*4 + 8*i + j + k, (len(s),3*4 + 8*i + j + k)
longs = struct.unpack(">%dq"%i,s[12:12+i*8])
str1 = s[12+i*8:12+i*8+j]
str2 = s[12+i*8+j:]
return (longs,str1,str2)
struct_header_2 = struct.Struct(">iii")
def encode_struct_2(longs,str1,str2):
return "".join((
struct_header_2.pack(len(longs),len(str1),len(str2)),
array.array("L",longs).tostring(),
str1,
str2))
def decode_struct_2(s):
i, j, k = struct_header_2.unpack(s[:12])
assert len(s) == 3*4 + 8*i + j + k, (len(s),3*4 + 8*i + j + k)
longs = array.array("L")
longs.fromstring(s[12:12+i*8])
str1 = s[12+i*8:12+i*8+j]
str2 = s[12+i*8+j:]
return (longs,str1,str2)
def encode_ujson(*args):
return ujson.dumps(args)
def encode_msgpack(*args):
return msgpacker.pack(args)
def decode_msgpack(s):
msgunpacker.feed(s)
return msgunpacker.unpack()
def encode_bson(longs,str1,str2):
return bson.dumps({"longs":longs,"str1":str1,"str2":str2})
def from_dict(d):
return [d["longs"],d["str1"],d["str2"]]
tests = [ #(encode,decode,massage_for_check)
(encode_struct_1,decode_struct_1,None),
(encode_struct_2,decode_struct_2,None),
(encode_json_1,json.loads,None),
(encode_json_2,json.loads,from_dict),
(encode_pickle,pickle.loads,None),
(encode_cPickle,cPickle.loads,None),
(encode_marshal,marshal.loads,None)]
try:
import ujson
tests.append((encode_ujson,ujson.loads,None))
except ImportError:
print "no ujson support installed"
try:
import msgpack
msgpacker = msgpack.Packer()
msgunpacker = msgpack.Unpacker()
tests.append((encode_msgpack,decode_msgpack,None))
except ImportError:
print "no msgpack support installed"
try:
import bson
tests.append((encode_bson,bson.loads,from_dict))
except ImportError:
print "no BSON support installed"
longs = [i for i in xrange(10000)]
str1 = "1"*5000
str2 = "2"*5000
random.seed(1)
encode_data = [[
longs[:random.randint(2,len(longs))],
str1[:random.randint(2,len(str1))],
str2[:random.randint(2,len(str2))]] for i in xrange(1000)]
for encoder,decoder,massage_before_check in tests:
# do the encoding
start = time.time()
encoded = [encoder(i,j,k) for i,j,k in encode_data]
encoding = time.time()
print encoder.__name__, "encoding took %0.4f,"%(encoding-start),
sys.stdout.flush()
# do the decoding
decoded = [decoder(e) for e in encoded]
decoding = time.time()
print "decoding %0.4f"%(decoding-encoding)
sys.stdout.flush()
# check it
if massage_before_check:
decoded = [massage_before_check(d) for d in decoded]
for i,((longs_a,str1_a,str2_a),(longs_b,str1_b,str2_b)) in enumerate(zip(encode_data,decoded)):
assert longs_a == list(longs_b), (i,longs_a,longs_b)
assert str1_a == str1_b, (i,str1_a,str1_b)
assert str2_a == str2_b, (i,str2_a,str2_b)
给予：
encode_struct_1 encoding took 0.4486, decoding 0.3313
encode_struct_2 encoding took 0.3202, decoding 0.1082
encode_json_1 encoding took 0.6333, decoding 0.6718
encode_json_2 encoding took 0.5740, decoding 0.8362
encode_pickle encoding took 8.1587, decoding 9.5980
encode_cPickle encoding took 1.1246, decoding 1.4436
encode_marshal encoding took 0.1144, decoding 0.3541
encode_ujson encoding took 0.2768, decoding 0.4773
encode_msgpack encoding took 0.1386, decoding 0.2374
encode_bson encoding took 55.5861, decoding 29.3953
bson、msgpack 和 ujson 均通过 easy_install 安装
我会喜欢被证明我做错了；我应该使用 cStringIO 接口，否则你会加快速度！
肯定有一种方法可以更快地序列化这些数据吗？
【问题讨论】：
-
对于python端的序列化，你可以使用cpickle，因为它比pickle快10倍以上。在服务器端，可以使用StringBuilder（如果你正在寻找优化，并且不需要并发访问）
-
我不确定用其他东西替换 json 是否是个好主意。如果 python 端在 jython 中，那么在 java 中的序列化将是一个很好的想法。
-
为什么不尝试一个简单的分隔字符串。 "1|2|3|4|foo|bar" 如果你能找到一个永远不会出现在你的字符串值中的分隔符，那么使用 String.Split 将是最快的'反序列化'
-
如果您使用二进制协议，pickle/cPickle 实际上比您的测试结果显示的要好得多。只需将 .dumps(args) 更改为 .dumps(args, -1) 或 .dumps(args, cPickle.HIGHEST_PROTOCOL)。当我用这些修改重新运行你的基准测试时，cPickle 实际上能够在组合编码/解码时间上击败 msgpack。我意识到对于 Java 互操作性，pickle 不是一个选项，但如果您只使用 Python 并且可以信任您的数据（因为可以使 pickle 执行任意代码），它可能已经足够快了。
-
如果速度很重要，那么大小也很重要 - 传递信息所需的字节越少，您在相同时间内可以传输的信息就越多。 msgpack 在您在此处提供的测试中击败了所有这些大小选项。
标签： java python performance optimization serialization