#include <iostream>
#include ".. estalS_utinity.h"
#include <list>
#include <vector>
#include "stdio.h"
#include <map>
//代理类,可以默认,就可以用对象数组,成员为指针,可以为0.有copy3件套.代理行为,检测0,
//什么时候需要写继承.感觉应该必须满足一个条件.就是需要多态.如果不需要多态.就算是is a,关系.也没有必要非整出一个基类.
//只要继承,就会使用指针来表示多态.只要有指针,就必须用代理类.
//所以只要继承就必须代理.
using namespace std;
class vehicle
{
public:
virtual double weight()=0;
virtual void start()=0;
};
class bike:public vehicle
{
public:
double weight();
void start();
};
class bus:public vehicle
{
public:
double weight();
void start();
};
class car:public vehicle
{
public:
double weight();
void start();
};
double bike::weight()
{
return 200;
}
void bike::start()
{
}
double bus::weight()
{
return 2000;
}
void bus::start()
{
}
double car::weight()
{
return 400;
}
void car::start()
{
}
class pm
{
public:
pm(vehicle*);
vehicle* getP();
~pm();
private:
pm();
pm(const pm&);
pm operator=(const pm&);
vehicle * pveh;
};
pm::pm(vehicle* _p):pveh(_p){}
pm::~pm(){delete pveh;}
vehicle* pm::getP(){return pveh;}
//一,对于单资源(狭义上就是内存,再狭义就是堆内存)的使用和管理.
//1,资源的建立和托管必须是一个步骤.2)托管对象必须保证和资源同生死.
//对于栈内存,.bike mybike1; 对于堆内存.bike * mybike2=new bike();
//第一种,很可靠.
//第二种,需要显示维护内存,和保护指针变量.所以引出一条款(effect c++),用对象管理资源.
//而资源管理对象和资源同生死.就必须保证资源建立和对象建立是原子操作.也是另一条款.
//并且资管,由于资源入对象是原操,那么资管必须负责资源的delete.
//1)资管必须负责资源的delete.
//2)负责delete,也就必须考虑资源copy三函数,构造,赋值,析构.
//3)资管可以没有默认的构造函数,
//4)可以直接用方法提供只读的资源地址,供外部使用
//对于第2条.如果是资源地址copy.资管转化为智能指针类.
//如果是资源copy.提供正确的构造,赋值,析构.
//如果是禁止资源copy,构造,赋值,析构.设置为private.
//如果是资源转移.提供正确的构造,赋值,析构.
//所以最终对于单资源的资源的使用.在c++中有2种比较可靠的方法.
//1)栈内存, bike mybike1;
//2)堆内存,pm mypm(new bike());
//对于多资源的统一使用和管理.
//基本是对于含有继承关系的对象而言.没有继承关系,谈不上统一管理.
//那么必须是管理指针.参考上面分析.必须建立对象.
//那么必须要求资源有默认的构造函数.
void showWeight(vehicle * _p)
{
cout<<_p->weight()<<endl;
}
int main()
{
//地址copy,使用智能指针类.
bike mybike1;
cout<<"**auto p***"<<endl;
showWeight(&mybike1);
//地址copy,使用智能指针类.
cout<<"**copy p***"<<endl;
pm_copyP<bike> mypm(new bike());
pm_copyP<bike> mypm2=mypm;
pm_copyP<bike> mypm3(new bike());
mypm3=mypm;
showWeight(mypm.getP());
showWeight(mypm2.getP());
showWeight(mypm3.getP());
//禁止copy值或地址.使用禁止类.
cout<<"**forbiden***"<<endl;
pm_forbidP<bike> mypm4(new bike());
showWeight(mypm4.getP());
//pm_forbidP<bike> mypm5=mypm4;//禁止复制,赋值.
//value copy,使用value-copy类.
cout<<"**copy value***"<<endl;
pm_copyValue<bike> mypm5(new bike());
pm_copyValue<bike> mypm6=mypm5;
pm_copyValue<bike> mypm7(new bike());
mypm7=mypm5;
showWeight(mypm5.getP());
showWeight(mypm6.getP());
showWeight(mypm7.getP());
//转移资源所有权, 使用transforP类. 这个和其他有不同.使用指针必须先判断,指针是否已经转移,为0了.
cout<<"**transforP***"<<endl;
pm_transforP<bike> mypm8(new bike());
pm_transforP<bike> mypm9=mypm8;
pm_transforP<bike> mypm10(new bike());
mypm10=mypm8;
if(mypm8.getP()!=0)
{
showWeight(mypm8.getP());
}
if(mypm9.getP()!=0)
{
showWeight(mypm9.getP());
}
if(mypm10.getP()!=0)
{
showWeight(mypm10.getP());
}
// vehicle* allCar[100]={0};
//
// bike mybike1;
// bus mybus1;
// car mycar1;
//
// allCar[0]=&mybike1;//这里是函数内,如果是外部参数,那么会有悬指针问题.所以条款,对象管理资源很必要.
// allCar[1]=&mybus1;
// allCar[2]=new car;//这里必须管理内存.
//
//
// for(int i=0;i!=100;++i)
// {
// if(allCar[i]!=0)
// {
// cout<< allCar[i]->weight()<<endl;
// }
// }
return 0;
}
#ifndef LS_UTINITY_H_INCLUDED #define LS_UTINITY_H_INCLUDED #include <iostream> #include <list> #include <vector> using namespace std; //智能指针 template<typename T> class auto_MyP { public: auto_MyP<T>(); auto_MyP<T>(T const* _p); auto_MyP<T>(const auto_MyP&); auto_MyP<T>& operator=(const auto_MyP&); T* getP()const; ~auto_MyP<T>(); void del(); private: int * count_ref; const T* autop; }; template<typename T> auto_MyP<T>::auto_MyP() { autop=0x0; count_ref=new int(1); } template<typename T> auto_MyP<T>::auto_MyP(T const* _p) { cout<<"p con:"<<_p<<endl; autop=_p; count_ref=new int(1); } template<typename T> auto_MyP<T>::auto_MyP(const auto_MyP& _lht) { autop=_lht.autop; ++(*_lht.count_ref); count_ref=_lht.count_ref; } template<typename T> auto_MyP<T>& auto_MyP<T>::operator=(const auto_MyP& _lht) { if(this!=&_lht) { del(); this->autop=_lht.autop; *_lht.count_ref=*_lht.count_ref+1; this->count_ref=_lht.count_ref; } return *this; } template<typename T> auto_MyP<T>::~auto_MyP() { del(); } template<typename T> void auto_MyP<T>:: del() { cout<<"false del:"<<*(this->count_ref)<<". add"<<autop<<endl; *(this->count_ref)=*(this->count_ref)-1;//前后自增加,就是此语句取值是取+1变量,还是把+1给临时变量,取值去取未+1的符号变量. if(*(this->count_ref)==0) { cout<<"del:"<<autop<<endl; //if(autop!=0x0) //{ delete autop; //} } } template<typename T> T* auto_MyP<T>::getP()const { return const_cast<T*>(autop); } //Merge sort template<typename T> list<T> mergeSort(const list<T>& source); template<typename T> list<T> mergeSort(const list<T>& source) { list<T> ret; if(source.size()==1) { ret=source; } else if(source.size()==2) { typename list<T>::const_iterator firstit=source.begin(); T firstvalue=*firstit; typename list<T>::const_iterator secondit=++firstit; T secondvalue=*secondit; if(firstvalue<=secondvalue) { ret=source; } else { ret.push_back(secondvalue); ret.push_back(firstvalue); } } else { unsigned int count_list=source.size(); unsigned int modN= count_list%2; unsigned int subret=count_list/2; typename list<T>::const_iterator it=source.begin(); list<T> leftS; list<T> rightS; for(int i=0;i!=subret+modN;++i) { leftS.push_back(*it); ++it; } for(int i=0;i!=subret;++i) { rightS.push_back(*it); ++it; } leftS=mergeSort(leftS);//lefts 传递const 引用,效率和安全,不会改动.返回对象.lefts被copy赋值函数处理. rightS=mergeSort(rightS); typename list<T>::const_iterator lefttop=leftS.begin(); typename list<T>::const_iterator righttop=rightS.begin(); while(lefttop!=leftS.end() || righttop!=rightS.end()) { // check each top if(*lefttop<=*righttop) { ret.push_back(*lefttop); ++lefttop; } else { ret.push_back(*righttop); ++righttop; } } if(lefttop!=leftS.end()) { //push no process data for(lefttop;lefttop!=leftS.end();++lefttop) { ret.push_back(*lefttop); } } else if(righttop!=rightS.end()) { for(righttop;righttop!=rightS.end();++righttop) { ret.push_back(*righttop); } } return ret; } return ret; } // template<typename T> void quickSort(vector<T>& source, int startIndex, int endIndex) { if(startIndex<endIndex) { int centerIndex=startIndex; for( int i=startIndex+1;i!=endIndex+1;++i) { if(source[i]<source[centerIndex]) { T tempT=source[i]; for( int j=i-1;j!=centerIndex-1;--j) { source[j+1]=source[j]; } source[centerIndex]=tempT; ++centerIndex; } } quickSort(source,startIndex,centerIndex-1); quickSort(source,centerIndex+1,endIndex); } } template<typename T> int centerFind(const vector<T>& source,const T& finder) { int ret=-2; int startIndex=0; int endIndex=source.size()-1; int CenterIndex=startIndex+(endIndex-startIndex)/2; while(ret==-2) { if(CenterIndex==startIndex&&startIndex==endIndex)//1个数 { if(source[CenterIndex]==finder) { ret=CenterIndex; } else { ret=-1; } } else { if(source[CenterIndex]==finder) { ret=CenterIndex; } else if(source[CenterIndex]>finder) { endIndex=CenterIndex-1; CenterIndex=startIndex+(endIndex-startIndex)/2; if(startIndex>endIndex) { ret=-2; } } else { startIndex=CenterIndex+1; CenterIndex=startIndex+(endIndex-startIndex)/2; if(startIndex>endIndex) { ret=-2; } } } } return ret; } template<typename T> class pm_copyP{ public: pm_copyP(T* _p); pm_copyP(const pm_copyP&); pm_copyP& operator=(const pm_copyP&); ~pm_copyP(); T* getP(); private: pm_copyP(); T* myp; int * count_ref; del(); }; template<typename T> pm_copyP<T>::pm_copyP(T* _p):myp(_p),count_ref(new int(1)){} template<typename T> pm_copyP<T>::pm_copyP(const pm_copyP& _pm) { myp=_pm.myp; count_ref=_pm.count_ref; ++(*count_ref); } template<typename T> pm_copyP<T>& pm_copyP<T>::operator=(const pm_copyP& _pm) { if(&_pm!=this) { del(); myp=_pm.myp; count_ref=_pm.count_ref; ++(*count_ref); } return *this; } template<typename T> pm_copyP<T>::~pm_copyP() { del(); } template<typename T> pm_copyP<T>::del() { --(*count_ref); if(*count_ref==0) { delete myp; delete count_ref; } } template<typename T> T* pm_copyP<T>::getP() { return myp; } template<typename T> class pm_forbidP{ public: pm_forbidP(T* _p); ~pm_forbidP(); T* getP(); private: T* myp; pm_forbidP(); pm_forbidP(const pm_forbidP&); pm_forbidP& operator=(const pm_forbidP&); }; template<typename T> pm_forbidP<T>::pm_forbidP(T* _p):myp(_p){} template<typename T> T* pm_forbidP<T>::getP() { return myp; } template<typename T> pm_forbidP<T>::~pm_forbidP() { delete myp; } template<typename T> class pm_copyValue{ public: pm_copyValue(T* _p); pm_copyValue(const pm_copyValue&); pm_copyValue& operator=(const pm_copyValue&); ~pm_copyValue(); T* getP(); private: T* myp; void del(); pm_copyValue(); }; template<typename T> pm_copyValue<T>::pm_copyValue(T* _p):myp(_p){} template<typename T> pm_copyValue<T>::pm_copyValue(const pm_copyValue& _pm):myp(new T(*_pm.myp)){} template<typename T> pm_copyValue<T>& pm_copyValue<T>::operator=(const pm_copyValue& _pm) { if(&_pm!=this) { del(); myp=new T(*_pm.myp); } return *this; } template<typename T> pm_copyValue<T>::~pm_copyValue() { del(); } template<typename T> void pm_copyValue<T>::del() { delete myp; } template<typename T> T* pm_copyValue<T>::getP() { return myp; } template<typename T> class pm_transforP{ public: pm_transforP(T* _p); pm_transforP(pm_transforP&); pm_transforP& operator=(pm_transforP&); ~pm_transforP(); T* getP(); private: T* myp; void del(); pm_transforP(); }; template<typename T> pm_transforP<T>::pm_transforP(T* _p):myp(_p){} template<typename T> pm_transforP<T>::pm_transforP(pm_transforP& _pm):myp(_pm.myp) { _pm.myp=0;//const 怎么可以修改. } template<typename T> pm_transforP<T>& pm_transforP<T>::operator=(pm_transforP& _pm) { if(this!=&_pm) { del(); myp=_pm.myp; _pm.myp=0;//const 怎么可以修改. } return *this; } template<typename T> pm_transforP<T>::~pm_transforP() { del(); } template<typename T> void pm_transforP<T>::del() { if(myp!=0) { delete myp; } } template<typename T> T* pm_transforP<T>::getP() { return myp; } #endif // LS_UTINITY_H_INCLUDED
关于异常：
#include <iostream> #include <stdexcept> using namespace std; //c++,实在经验不足.感觉只能是,使用某些函数,又不想每次都检测是否返回正确.那么抛出错误.程序结束. //感觉还不如返回错误代码呢. int dev(int a,int b); int main() { int result=0; try { result=dev(3,1); } catch(exception &e) { //提示错误,保存关键数据,程序退出 cout<<e.what()<<endl; return -1; } cout<<result<<endl; return 0; } int dev(int a,int b) { if(b==0) { throw runtime_error("b is zero"); } else if(b==1) { throw logic_error("b can not be 1"); } else { return a/b; } return 0; }
关于类的数据成员和参数问题。以及const。
1)类的data member.
如果是内置类型或类的值类型,语义就是局部数据,const语义就是,在类内,一个局部常量.
如果是内置类型或类的指针或引用类型,语义就是局部的指针,指向外部数据,const语义就是,在类内,不可通过此指针修改外部数据.
如果是内置类型或类的智能指针类型.语义就是局部数据,但里面有指针指向外部数据.const语义就是,在类内,不可通过此局部数据中的指针修改外部数据.
(可以完全代替第二种,只是size为8,而第2中size是4(32system)).
如果是内置类型或类的智能指针的指针或引用类型.语义就是很大概率是你想的的太复杂了.请退化为第3种.智能指针就是为了自动释放内存.
再保存它的指针,又把问题解决方案变成了问题本身.餐巾纸的作用就是为了吃饭时,让衣服更干净.为了方便拿东西.又套一个外套,还不如拿掉餐巾纸.
但是构造函数的参数应该使用 智能指针的reference,这个时候智能指针当成一般类处理.智能指针本质就是一个类了.
总结:
值还是智能指针(指针),还是引用.
从数据库讲，
一个字段不是另一个表的key。那么就是值。否则就是引用。如果表不存在这个字读。那么就是用方法返回数据（查询其他表）
const还是非const?
可修改用非const.否则用const.
对于智能指针,指针不可修改用 const shared_ptr<T>,指针所指的数据不可修改用shared_ptr<const T>.
从数据库讲。如果一个字段设置了触发器，字段是只读了。那么类中。一定要是const。
2)类的constructor的参数.
如果参数是内置类型或类的值类型,语义就是会创建一个原数据的副本,压入函数体.const语义就是,此参数的数据不可修改.但可以赋值给const或非const.
如果参数是内置类型或类的指针或引用类型,语义就是引用原数据,压入原数据的指针到函数体.const语义就是此地址的指向不可修改.
如果参数是内置类型或类的智能指针类型.语义就是会创建一个原数据(包含一个指针)的副本,压入函数体.const语义就是,此参数的数据不可修改.也就是里面的地址的指向不可修改.
时钟周期
时钟周期也称为振荡周期，定义为时钟脉冲的倒数（时钟周期就是单片机外接晶振的倒数，例如12M的晶振，它的时钟周期就是1/12us），是计算机中的最基本的、最小的时间单位。
在一个时钟周期内，CPU仅完成一个最基本的动作。时钟脉冲是计算机的基本工作脉冲，控制着计算机的工作节奏。时钟频率越高，工作速度就越快。
8051单片机把一个时钟周期定义为一个节拍（用P表示），二个节拍定义为一个状态周期（用S表示）。
机器周期
计算机中，常把一条指令的执行过程划分为若干个阶段，每一个阶段完成一项工作。每一项工作称为一个基本操作，完成一个基本操作所需要的时间称为机器周期。8051系列单片机的一个机器周期由6个S周期（状态周期）组成。 一个S周期=2个节拍（P），所以8051单片机的一个机器周期=6个状态周期=12个时钟周期。
例如外接24M晶振的单片机，他的一个机器周期=12/24M 秒；
指令周期
执行一条指令所需要的时间，一般由若干个机器周期组成。指令不同，所需的机器周期也不同。
int main(void)
{
char buf[10];
int n = read(STDIN_FILENO, buf, 10);
write(STDOUT_FILENO, buf, n);
return 0;
}
输入字符，回车后。。。。。
少于等于10个ok。大于10个。后续的字符，和回车键都还在标准输出中，会认为用户敲入了命令。
关于开发整体流程。
//对于开发的流程,个人倾向,先建模,后建表.再实际建立class.
//因为先建立表,可以更快理清类之前细节.因为建类的时候需要考虑实际数据的存放问题.
//建立类的时候,发现问题.也可以修改表.
//而建立好类,不满足表,改类就麻烦.
//再次.表的话更直观,可以先不考虑细节.从整体掌握模型的数据流是否正确.
//甚至,类中犯的错误的设计,在表中就不太会出现.如员工,和职务.表明显会有好几个.一个员工表,几个不同职务表.
//而类,可能会设计为一个类.建模错误,会导致表设计不符合表设计范式.
//但是设计表的时候也可以考虑一下类.是否需要多一个表,来表现包含关系.或继承关系.
再一次卡在设计流程上了。
继续卡在无数据库设计上。
有数据库设计，数据存放问题不用考虑。而无数据库，放在那里，用 vector 对象还是指针，总是感觉设计不好。用vector或智能指针。
应该还是基于分析后。关系型数据设计开路（好理解，也很熟悉），数据存放问题的话。去掉表的外键，放入外键所在的表。用vector直接存放对象。，vector自己离开作用域会自动析构。析构会调用成员的析构函数并释放堆空间。完美啊。
可以先省去内部中其他类的集合。从上往下设计下来就好，下级设计好了。再返回上级，使用下级的初始化函数，来修改上级的初始化函数或其它初始化的地方。
这样设计了数据的流向后，再从面向对象的思维，设计行为。来给数据流向取个名字。
对象间的数据存放问题。
1）如果原本数据成员都不多。那么偏向一方（其中有确定数据属于的那方）。
2）用map存储数据。类方法提供对map的真删改，查， 类本身或管理类提供逻辑，调用增删改，特别注意逻辑中含删除的操作。
单个数据直接放栈，如果太大用智能指针。如果是不确定的多个数据或者多个大数据。用vector就好了。甚至单个大数据也可以用vector，vector自己离开作用域会自动析构。析构会调用成员的析构函数并释放堆空间。完美啊。
定义参数值用全局const。但如果是状态返回值或者作为参数可以用enum.这样就可以限定返回的数据范围。但是枚举不能设定数据类型。比如int_8，所以在网络编程需要固定长度的时候又很尴尬。
模型设计的一点想法，
看了下网狐。有个设计，类之间的包含关系 ，不放指针，或智能指针。
直接放一个key.
所以设计的时候，
1.可以先设计一个对象，包含属性和方法。
2.再设计一个管理类，包含一个当前key 的最大小（根据情况，是先进先出，还是先进后出）值。 用int 记录。
一般可以用int ,取int最大值为默认值，表示下次插入的key。插入的时候用这个做key.并·--, 删除的时候，看看要删除的是不是等于 key-1.如果是，++。 所以用map的key，来当前数据库的外键。
好处是避免了指针的坏处。指针可能有移动操作，也比较危险。而用 key，自然的多。终于解决了这个疑问。
封装的一个含义就是类的某个或几个数据是状态数据。他的改变只由行为（方法）来改变。并提供只读的查看。
服务端和客户端同步开发。
客户端的初始化行为放入main中（之后可以由网络模块发送消息，获得消息，并回调这些方法）。
客户端的动作逻辑封装成方法（之后由网络模块发送消息，获得消息，并回调这些方法）
服务端是一个完备的系统，应该是一个可以自检，自运行的系统。客户端只是通过发送消息，改变服务端的自运行的过程中的状态值。
c#
RoomInfo selectroom = rooms.Where(s => s.room_id == (SByte)this.comboBox1.SelectedValue).Single();
where 相当于里面一个bool函数。where里面已经回调了（）里面的函数。并根据bool值来决定是否加入结果集合。
c++ get .set 生成器。
List<string> inputcode = new List<string>(); List<string> outputcode = new List<string>(); string className = this.textBox3.Text.Trim(); inputcode = this.textBox1.Text.Split(new string[] {" "}, StringSplitOptions.RemoveEmptyEntries).ToList(); for(int i=0;i<inputcode.Count;++i) { string[] eachline=inputcode[i].Split(new string[] {" ",";"}, StringSplitOptions.RemoveEmptyEntries); if(eachline.Count()==2) { string type=eachline[0]; string name=eachline[1]; this.textBox2.Text+=type+" "+className+"::Get"+name+"()"+System.Environment.NewLine; this.textBox2.Text+="{"+System.Environment.NewLine; this.textBox2.Text += " " + "return " + name + ";" +System.Environment.NewLine; this.textBox2.Text+="}"+System.Environment.NewLine; this.textBox2.Text+="void "+className+"::Set"+name+"("+type+" _"+name+")"+System.Environment.NewLine; this.textBox2.Text+="{"+System.Environment.NewLine; this.textBox2.Text += " " + name + "=_" + name + ";" + System.Environment.NewLine; this.textBox2.Text+="}"+System.Environment.NewLine; this.textBox2.Text=this.textBox2.Text.Replace("std::",""); } }
目的：有时候有些情况比较复杂，写完了代码。也没法确定是否完全正确。画图感觉比较复杂，只能靠测试。这个时候使用状态机分析法。就能比较好。
步骤：先写出初始行为，和输入行为，以及输入行为对应的猜想的动作，通过猜想的动作，对状态的更改，判断状态是否合理，来验证行为是否正确。
每次集合中所有状态和行为一一匹配。有新状态。就保存。
之后每次用新状态和所有行为一一匹配。直到没有新状态为止。
初始状态： r_ok,s_ok,e_in;
输入行为和对应猜想动作()
1)recv_again. r_ok
2)recv_close. r_close,cancel event
3)recv_error. del
4)send_ok. s_ok ,1)close:yes,block:yes=>s_ok 2)close:yes,block:no => s_ok 3) colse:no,block:yes=>s_ok. e_in. 4)close:no,block:no=>s_ok
5)send_block. s_block,mod e_out
6)send_err. del
初始状态： 下和所有输入行为产生的新状态
1:r_ok,s_ok,e_in;
1-1)=>
1-2)=>r_close,s_ok
1-3)=>del
1-4)=>r_ok,s_ok,e_in
1-5)=>r_ok,s_block,e_out
1-6)=>del
状态应该正确。所以猜想行为暂时正确。
在用得到的新状态，和所有行为一一匹配
1:r_close,s_ok
2:r_ok,s_block,e_out
1-1)=>不可能会存在的行为
1-2)=>不可能会存在的行为
1-3)=>不可能会存在的行为
1-4)=>
1-5)=>r_close,s_block, e_out
1-6)=>del
2-1)=>不可能会存在的行为
2-2)=>不可能会存在的行为
2-3)=>不可能会存在的行为
2-4)=>
2-5)=>
2-6)=>del
又得到1种新状态。所有状态是2×2×2.现在只有4种。
在用得到的新状态，和所有行为一一匹配
1：r_close,s_block, e_out
1-1)=>不可能会存在的行为
1-2)=>不可能会存在的行为
1-3)=>不可能会存在的行为
1-4)=>
1-5)=>
1-6)=>del
无任何新状态。估算下是否正确
估算下，还有剩下4种是什么情况。
1:r_ok,s_ok,e_in;
2:r_ok,s_block,e_out
3:r_close,s_ok
4：r_close,s_block, e_out
哦。因为s_ 和e_只能组合成2种。
所以就是4种。
所以我们得到了全部状态。再验证一下猜想行为就好了。
虽然很烦琐，但是可以验证遗漏的情况。
测试epoll的时候，客户端可以线程10个内。但是开多点socket ，100左右。这样简陋的环境。也可以测试高流量，模拟高并发。注意看服务的发送和接受是否相同大小，如果是echo测试。
还要看客户端的接受。是否有重传现象。如果客户端接收的明显比服务端发送的多。
如何测试epoll的代码效率。
可以简单点。客户端开1000个socket.200毫毛休息一次。说明1秒有5000条信息处理。每条信息64B。发送速度就是300/kB.
服务端，每条信息的处理休息1毫秒。说明1秒处理1000条。但是测试还是不准。所以可以调整下。用netstat 命令查看。使得接受数据越来越多为好。说明程序处理慢。
这样就可以开始优化了。单线程可以优化批量发送，批量处理。
多线程就可以开始队列，新线程处理。多线程的一般特征是网路是没有问题的。接受快，发送快。因为单独线程再处理io。但是如果程序差，那么内存会原来越小。因为网络的数据全部拉到内存中去了。但是又处理不过来。