jsoncpp 执行效率优化，非常规极限优化，适合linux下， 效率几乎提高50%以上

这是2年多前， 一个游戏服务器项目要上线了，协议消息处理和数据存放都基本用json的，用的是jsoncpp开源库

主要逻辑处理部分是单线程处理，所以玩家一多cpu就吃不消了， 要优化，

用gprof等工具找啊找研究发现是 主要json部分引起的一些内存开销占用cpu资源过多。（还有一些智能指针，按下不表）

找了很多方法优化jsoncpp，

1.比如 http://www.2cto.com/kf/201211/172375.html

只优化了一些。

2.另外， Json::Value对象有个 swap接口，所有的 赋值操作能改 swap的都用swap（因为直接 = 赋值，会做一次对象拷贝）

3. 然后 数据嵌套的 基本不用append ， 都用  Json::Value &one = jv_test[jv_test.size()];  先取出来再赋值，这样就省了 append时的一次拷贝

4.StyledWriter尽量都变成 FastWriter的格式化

但改了好多代码，只是稍稍提高了点效率

5. 继续修改jsoncpp源码 把注释的处理代码去掉，好像用处也不大。

后来仔细看了一下jsoncpp代码， 发现 特别是writer里面， 有个字符串document_ 一直再 += ， 拼接字符串，

原先代码 没用用一个统一的writer格式化， 很多都是用toStyledString()

std::string Value::toStyledString() const {

  //StyledWriter writer;

  FastWriter writer;

  return writer.write(*this);

}

可想而知 这个document_ 这个字符串容器在 拼接字符串要分配多少次内存哈，不可想象。

如果改代码，量太大

就直接改底层的

一、writer.h里 注掉

 //std::string document_;

二、json_writer.h里改一下代码   

使用一个 线程级的 全局静态变量 替换 document_; 

std::string valueToQuotedString(const char *value, <strong>std::string* document</strong> /* = NULL*/) {
if (value == NULL)
return "";
// Not sure how to handle unicode...
if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL &&
!containsControlCharacter(value))
{<strong>
if(document != NULL)
{
std::string tmp = std::string("\"") + value + "\"";
*document += tmp;
return "";
}
else
{
return std::string("\"") + value + "\"";
}</strong>
}
// We have to walk value and escape any special characters.
// Appending to std::string is not efficient, but this should be rare.
// (Note: forward slashes are *not* rare, but I am not escaping them.)
std::string::size_type maxsize =
strlen(value) * 2 + 3; // allescaped+quotes+NULL
std::string new_result;
std::string* result = &new_result;
if(document != NULL)
{
result = document;
}
else
{
(*result).reserve(maxsize); // to avoid lots of mallocs
}
(*result) += "\"";
for (const char *c = value; *c != 0; ++c) {
switch (*c) {
case '\"':
(*result) += "\\\"";
break;
case '\\':
(*result) += "\\\\";
break;
case '\b':
(*result) += "\\b";
break;
case '\f':
(*result) += "\\f";
break;
case '\n':
(*result) += "\\n";
break;
case '\r':
(*result) += "\\r";
break;
case '\t':
(*result) += "\\t";
break;
// case '/':
// Even though \/ is considered a legal escape in JSON, a bare
// slash is also legal, so I see no reason to escape it.
// (I hope I am not misunderstanding something.
// blep notes: actually escaping \/ may be useful in javascript to avoid </
// sequence.
// Should add a flag to allow this compatibility mode and prevent this
// sequence from occurring.
default:
if (isControlCharacter(*c)) {
std::ostringstream oss;
oss << "\\u" << std::hex << std::uppercase << std::setfill('0')
<< std::setw(4) << static_cast<int>(*c);
(*result) += oss.str();
} else {
(*result) += *c;
}
break;
}
}
(*result) += "\"";
return new_result;
}
<strong>
//暂不考虑释放问题，如果线程不停创建使用，自动释放请参考http://www.searchtb.com/2012/09/tls.html
static __thread std::string* jw_document_ = NULL;

#define document_ (*jw_document_)</strong>
// Class Writer
// //////////////////////////////////////////////////////////////////
Writer::~Writer() {}

// Class FastWriter
// //////////////////////////////////////////////////////////////////

FastWriter::FastWriter()
: yamlCompatiblityEnabled_(false), dropNullPlaceholders_(false) {
<strong>      if(NULL == jw_document_)
{
jw_document_ = new std::string();
//printf("###FastWriter::FastWriter() new string()\n");
}</strong>
}

void FastWriter::enableYAMLCompatibility() { yamlCompatiblityEnabled_ = true; }

void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; }

std::string FastWriter::write(const Value &root) {
<strong>  document_.clear();</strong>
writeValue(root);
//document_ += "\n";
return document_;
}

void FastWriter::writeValue(const Value &value) {
switch (value.type()) {
case nullValue:
if (!dropNullPlaceholders_)
document_ += "null";
break;
case intValue:
document_ += valueToString(value.asLargestInt());
break;
case uintValue:
document_ += valueToString(value.asLargestUInt());
break;
case realValue:
document_ += valueToString(value.asDouble());
break;
case stringValue:<strong>
//document_ += valueToQuotedString(value.asCString());
valueToQuotedString(value.asCString(),&document_);</strong>
break;
case booleanValue:
document_ += valueToString(value.asBool());
break;
case arrayValue: {
document_ += "[";
int size = value.size();
for (int index = 0; index < size; ++index) {
if (index > 0)
document_ += ",";
writeValue(value[index]);
}
document_ += "]";
} break;
case objectValue: {
document_ += "{";
Value::ObjectValues* value_map = value.getValueMap();
if(value_map != NULL)
{
Value::ObjectValues::iterator it = value_map->begin();
for ( Value::ObjectValues::iterator it = value_map->begin();
it != value_map->end();
++it )
{
if ( it != value_map->begin() )
document_ += ",";
const char* name = it->first.c_str();
valueToQuotedString( name, &document_ );
document_ += yamlCompatiblityEnabled_ ? ": " : ":";
writeValue( it->second );
}
}
/*
Value::Members members(value.getMemberNames());
document_ += "{";
for (Value::Members::iterator it = members.begin(); it != members.end();
++it) {
const std::string &name = *it;
if (it != members.begin())
document_ += ",";
document_ += valueToQuotedString(name.c_str());
document_ += yamlCompatiblityEnabled_ ? ": " : ":";
writeValue(value[name]);
}
*/
document_ += "}";
} break;
}

整体效率一下提高了50% - -！

<strong>__thread </strong>

是保证多线程下没有问题。

reader也可以优化看看。

这个优化如果有需要可以拿去试试。   个人觉得全局 统一用一个writer来输出也不错（不过要注意多线程的问题）。