muduo阅读涉及部分零散知识备忘

Muduo涉及知识点总结

shared_ptr以const reference方式作为函数参数传递。只要有指向对象x的shared_ptr存在对象x就不会析构,当指向x的最后一个shared_ptr析构或reset时x会被销毁.weak_ptr不控制对象生命期,但是它知道对象是否活着:若对象还活着它可以提升为shared_ptr,否则返回一个空shared_ptr,提升行为是线程安全的.

scoped_ptr:它能够保证在离开作用域后对象被自动释放,boost::scoped_ptr的实现和std::auto_ptr非常类似,都是利用了一个栈上的对象去管理一个堆上的对象,从而使得堆上的对象随着栈上的对象销毁时自动删除。不同的是,boost::scoped_ptr有着更严格的使用限制——不能拷贝。这就意味着:boost::scoped_ptr指针是不能转换其所有权的。不能转换所有权boost::scoped_ptr所管理的对象生命周期仅仅局限于一个区间(该指针所在的”{}”之间),无法传到区间之外,这就意味着boost::scoped_ptr对象是不能作为函数的返回值的(std::auto_ptr可以)。不能共享所有权这点和std::auto_ptr类似。这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱——不能用于stl的容器中。不能用于管理数组对象由于boost::scoped_ptr是通过delete来删除所管理对象的,而数组对象必须通过deletep[]来删除,因此boost::scoped_ptr是不能管理数组对象的,如果要管理数组对象需要使用boost::scoped_array类。

弱回调:如果对象还活着就调用它的成员函数否则忽略。利用weak_ptr在回调的时候尝试提升为shared_ptr,若提升成功说明对象还健在,执行回调,否则不回调

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应

mutable也是为了突破const的限制而设置的。被mutable修饰的变量,将永远处于可变的状态,即使在一个const函数中

静态数据成员和普通数据成员区:(1)普通数据成员属于类的一个具体的对象,只有对象被创建了,普通数据成员才会被分配内存。而静态数据成员属于整个类,即使没有任何对象创建,类的静态数据成员变量也存在,所有对象只有一份。(2)因为类的静态数据成员的存在不依赖与于任何类对象的存在(没有this指针),类的静态数据成员应该在代码中被显示的初始化,一定要在类外进行,例如上例。(3)外部访问类的静态成员只能通过类名来访问,例如:test::getCount()。(4)类的静态成员函数无法直接访问普通数据成员(可以通过类的指针等作为参数间接访问),而类的任何成员函数都可以访问类的静态数据成员。(5)静态成员和类的普通成员一样,也具有public、protected、private3种访问级别,也可以具有返回值、const修饰符等参数。虚函数、构造函数、析构函数不能为static(显然没有具体对象何来构造析构,静态何以动态重载)。应避免构造函数和析构函数调用虚函数(可能发生未定义行为)。

RAII:获取资源即初始化==初始化即获取资源,是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。RAII 的一般做法是这样的:在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处:1,我们不需要显式地释放资源。2,采用这种方式,对象所需的资源在其生命期内始终保持有效 —— 我们可以说,此时这个类维护了一个 invariant。这样,通过该类对象使用资源时,就不必检查资源有效性的问题,可以简化逻辑、提高效率。最简单的RAII形式是创建这样一个对象:构造函数中获取一份资源,析构函数中则释放资源。例如:class test{};template<typename T>class resourceHandle{resourceHandle(T* t):x(t);~resourceHandle(){delete x;}}在使用test前采用resourceHandle封装它则会不会出现内存泄露。

enable_shared_ptr_from_this:是一个以其派生类为模板类型实参的基类模板。继承它this指针就能变身shared_ptr。为了使用share_from_this()派生类不能是栈对象,必须是堆对象且有shared_ptr管理其生命周期。share_from_this()不能在构造函数里调用,因为在构造对象的时候对象还没有交个shared_ptr接管。

mutex有两种:递归(可重入,不用担心自己把自己锁死)和非递归(不可重入,同一线程不能重复对其加锁).同一线程可以重复对递归锁加锁但是不能重复对非递归锁加锁。pthread_mutex_t是非递归锁,可以显示的设置PTHREAD_MUTEX_RECURSIVE属性,将pthread_mutex_t设为递归锁。

spuriouswakeup(虚假唤醒):线程甚至在没有人向条件变量发送信号的情况下就有可能会被唤醒.notify或者notifyAll时,唤醒的并非满足了唤醒条件的线程。因为在notify或者notifyAll时不知道具体是唤醒的哪个线程,notify唤醒随机一个,notifyAll会唤醒所有对应的wait的线程,但是并非所有都是需要唤醒的,这个就是所谓的虚假唤醒了。

1 关于SIGPIPE 信号的产生和处理

如果客户端关闭套接字close,而服务器调用一次write, 服务器会接收一个RST segment(tcp传输层)如果服务器端再次调用了write,这个时候就会产生SIGPIPE信号,默认终止进程(通俗解释为 对一个对端已经关闭的socket调用两次write, 第二次将会生成SIGPIPE信号, 该信号默认结束进程.)可以在程序中直接忽略掉,如 signal(SIGPIPE, SIG_IGN);

具体的分析可以结合TCP的”四次握手”关闭. TCP是全双工的信道, 可以看作两条单工信道, TCP连接两端的两个端点各负责一条. 当对端调用close时, 虽然本意是关闭整个两条信道, 但本端只是收到FIN包. 按照TCP协议的语义, 表示对端只是关闭了其所负责的那一条单工信道, 仍然可以继续接收数据. 也就是说, 因为TCP协议的限制, 一个端点无法获知对端已经完全关闭.

1_1

对一个已经收到FIN包的socket调用read方法, 如果接收缓冲已空, 则返回0, 这就是常说的表示连接关闭. 但第一次对其调用write方法时, 如果发送缓冲没问题, 会返回正确写入(发送). 但发送的报文会导致对端发送RST报文, 因为对端的socket已经调用了close, 完全关闭, 既不发送, 也不接收数据. 所以, 第二次调用write方法(假设在收到RST之后), 会生成SIGPIPE信号, 导致进程退出.

 

解决办法:

为了避免进程退出, 可以捕获SIGPIPE信号, 或者忽略它, 给它设置SIG_IGN信号处理函数:

signal(SIGPIPE, SIG_IGN);

这样, 第二次调用write方法时, 会返回-1, 同时errno置为SIGPIPE. 程序便能知道对端已经关闭.

 

3、TIME_WAIT 状态对 服务器的影响

补充:TIME_WAIT状态

MSL(最大分段生存期)指明TCP报文在Internet上最长生存时间,每个具体的TCP实现都必须选择一个确定的MSL值。RFC 1122建议是2分钟。
TIME_WAIT 状态最大保持时间是2 * MSL,也就是1-4分钟。 IP头部有一个TTL,最大值255。尽管TTL的单位不是秒(根本和时间无关),我们仍需假设,TTL为255的TCP报文在Internet上生存时间不能超过MSL。 TCP报文在传送过程中可能因为路由故障被迫缓冲延迟、选择非最优路径等等,结果发送方TCP机制开始超时重传。前一个TCP报文可以称为”漫游TCP重复报文”,后一个TCP报文可以称为”超时重传TCP重复报文”,作为面向连接的可靠协议,TCP实现必须正确处理这种重复报文,因为二者可能最终都到达。

当一个socket关闭的时候,是通过两端互发信息的四次握手过程完成的,当一端调用close()时,就说明本端没有数据再要发送了。这好似看来在握手完成以后,socket就都应该处于关闭CLOSED状态了。但这有两个问题,
第一:我们没有任何机制保证最后的一个ACK能够正常送达
第二:网络上仍然有可能有残余的数据包(wandering duplicates,或老的重复数据包),我们也必须能够正常处理。

假设最后一个ACK丢失了,服务器会重发它发送的最后一个FIN,所以客户端必须维持一个状态信息,以便能够重发ACK;如果不维持这种状态,客户端在接收到FIN后将会响应一个RST,服务器端接收到RST后会认为这是一个错误。如果TCP协议能够正常完成必要的操作而终止双方的数据流传输,就必须完全正确的传输四次握手的四个节,不能有任何的丢失。这就是为什么socket在关闭后,仍然处于 TIME_WAIT状态,因为他要等待以便重发ACK。
如果目前连接的通信双方都已经调用了close(),假定双方都到达CLOSED状态,而没有TIME_WAIT状态时,就会出现如下的情况。现在有一个新的连接被建立起来,使用的IP地址与端口与先前的完全相同,后建立的连接又称作是原先连接的一个化身。还假定原先的连接中有数据报残存于网络之中,这样新的连接收到的数据报中有可能是先前连接的数据报。为了防止这一点,TCP不允许从处于TIME_WAIT状态的socket建立一个连接。处于TIME_WAIT状态的socket在等待两倍的MSL时间以后(之所以是两倍的MSL,是由于MSL是一个数据报在网络中单向发出到认定丢失的时间,一个数据报有可能在发送图中或是其响应过程中成为残余数据报,确认一个数据报及其响应的丢弃的需要两倍的MSL),将会转变为CLOSED状态。这就意味着,一个成功建立的连接,必然使得先前网络中残余的数据报都丢失了。
由于TIME_WAIT状态所带来的相关问题,我们可以通过设置SO_LINGER标志来避免socket进入TIME_WAIT状态,这可以通过发送RST而取代正常的TCP四次握手的终止方式。但这并不是一个很好的主意,TIME_WAIT对于我们来说往往是有利的。

TIME_WAIT状态对HTTP影响

根据TCP协议,主动发起关闭的一方,会进入TIME_WAIT状态,持续2*MSL(Max Segment Lifetime),缺省为240秒。值得一说的是,对于基于TCP的HTTP协议,关闭TCP连接的是Server端,这样,Server端会进入TIME_WAIT状态,可想而知,对于访问量大的Web Server,会存在大量的TIME_WAIT状态,假如server一秒钟接收1000个请求,那么就会积压240*1000=240000个TIME_WAIT的记录,维护这些状态给Server带来负担。当然现代操作系统都会用快速的查找算法来管理这些TIME_WAIT,所以对于新的TCP连接请求,判断是否hit中一个TIME_WAIT不会太费时间,但是有这么多状态要维护总是不好。

RFC793指出,MSL的值是2分钟,但是在实际的实现中,常用的值有以下三种:30秒,1分钟,2分钟。注意一个问题,进入TIME_WAIT状态的一般情况下是客户端,大多数服务器端一般执行被动关闭,不会进入TIME_WAIT状态,当在服务器端关闭某个服务再重新启动时,它是会进入TIME_WAIT状态的。

HTTP协议1.1版规定default行为是Keep-Alive,也就是会重用TCP连接传输多个request/response,一个主要原因就是发现了这个问题。还有一个方法减缓TIME_WAIT压力就是把系统的2*MSL时间减少,因为240秒的时间实在是忒长了点,对于Windows,修改注册表,一般认为不要少于60,不然可能会有麻烦。

 

如果服务器端 主动断开连接(先于client 调用close),服务器端就会进入TIME_WAIT 状态。应尽可能在服务器端避免TIME_WAIT 状态,因为它会在一定时间内hold住一些内核资源。协议设计上,应该让客户端主动断开连接,这样就把TIME_WAIT状态分散到大量的客户端。如果客户端不活跃了,一些不客户端不断开连接,这样就会占用服务器端的连接资源。服务器端也要踢掉不活跃的连接close。

3 c++ erase   返回的是下一个元素的iterator

4 、新的accept4 系统调用

accept – accept a connection on a socket

#include <sys/types.h>          /* See NOTES */

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <sys/socket.h>
int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);

可以使用accept4 这个新的系统调用,多了一个flags 参数,可以设置以下两个标志:

SOCK_NONBLOCK   Set the O_NONBLOCK file status flag on the new open file description.  Using this flag saves  extra  calls to fcntl(2) to achieve the same result.

SOCK_CLOEXEC    Set  the close-on-exec (FD_CLOEXEC) flag on the new file descriptor.  See the description of the O_CLOEXEC  flag in open(2) for reasons why this may be useful.

 

epoll  的两种模式处理流程和存在的问题

 

Level-Triggered //跟poll 基本类似

1_2

LT 电平触发(高电平触发):

EPOLLIN 事件

内核中的某个socket接收缓冲区     为空          低电平

内核中的某个socket接收缓冲区     不为空       高电平

EPOLLOUT 事件

内核中的某个socket发送缓冲区     不满          高电平

内核中的某个socket发送缓冲区     满             低电平

注:只要第一次write没写完整,则下次调用write直接把数据添加到应用层缓冲区OutBuffer,等待EPOLLOUT事件。

如果采用Level-Triggered,那什么时候关注EPOLLOUT事件?会不会造成busy-loop(忙等待)?

Edge-Triggered:

1_3

ET 边沿触发:

低电平-》高电平      触发

推荐epoll使用LT模式的原因:与poll兼容

LT模式不会发生漏掉事件的BUG,但POLLOUT事件不能一开始就关注,否则会出现busy loop(即暂时还没有数据需要写入,但一旦连接建立,内核发送缓冲区为空会一直触发POLLOUT事件),而应该在write无法完全写入内核缓冲区的时候才关注,将未写入内核缓冲区的数据添加到应用层output buffer,直到应用层output buffer写完,停止关注POLLOUT事件。

读写的时候不必等候EAGAIN,可以节省系统调用次数,降低延迟。(注:如果用ET模式,读的时候读到EAGAIN,写的时候直到output buffer写完或者写到EAGAIN)

 

补充

bufferevent读事件的高水位是什么意思?

读事件的低水位比较容易理解,当bufferevent读缓冲区的数据到达这个低水位后,用户设置的可读回调函数才会被调用。比如说,用户设置了4字节的低水位,因为用户认为少于4字节都是不值得去处理的。当bufferevent的读缓冲区的数据量小于4字节时,并不会调用用户的可读回调函数。当数据量大于等于4字节时,就会调用用户的可读回调函数。

读事件的高水位又是什么呢?在默认情况下(即没有设置高水位),一旦socket fd有数据可读了,那么libevent就会把数据从该socket fd的内核缓冲区 读取到bufferevent的读缓冲区中。客户端往服务器发送大量数据,服务器会不断地把数据copy到bufferevent缓冲区中。此时TCP的滑动窗口协议就没有用了。

读事件的高水位此时就应运而生了,当bufferevent读缓冲区的数据量达到这个高水位后,就不再从socket fd中读取数据了。此时,socket fd的内核缓冲区会堆积大量数据,滑动窗口协议就起作用了。当bufferevent的读缓冲区的数量少于高水位后,libevent又可以从socket fd的缓冲区读取数据。停止读取、恢复读取这一系列操作都是由libevent负责完成,用户完全不知情。

 

accept(2)返回EMFILE的处理(文件描述符已经用完)
(1)、调高进程文件描述符数目
(2)、死等
(3)、退出程序
(4)、关闭监听套接字。那什么时候重新打开呢?
(5)、如果是epoll模型,可以改用edge trigger。问题是如果漏掉了一次accept(2),程序再也不会收到新连接(没有状态变化)
(6)、准备一个空闲的文件描述符。遇到这种情况,先关闭这个空闲文件,获得一个文件描述符名额;再accept(2)拿到socket连接的文件描述符;随后立刻close(2),这样就优雅地断开了与客户端的连接;最后重新打开空闲文件,把“坑”填上,以备再次出现这种情况时使用。

面向对象  基于对象

面向对象的三大特点(封装,继承,多态)缺一不可。通常“基于对象”是使用对象,但是无法利用现有的对象模板产生新的对象类型,继而产生新的对象,也就是说“基于对象”没有继承的特点。而“多态”表示为父类类型的子类对象实例,没有了继承的概念也就无从谈论“多态”。现在的很多流行技术都是基于对象的,它们使用一些封装好的对象,调用对象的方法,设置对象的属性。但是它们无法让程序员派生新对象类型。他们只能使用现有对象的方法和属性。所以当你判断一个新的技术是否是面向对象的时候,通常可以使用后两个特性来加以判断。“面向对象”和“基于对象”都实现了“封装”的概念,但是面向对象实现了“继承和多态”,而“基于对象”没有实现这些。—-摘自网络

 

使用PRld64

int64_t 用来表示64位整数,在32位系统中是long long int,在64位系统中是long int,所以打印int64_t的格式化方法是:
printf(“%ld”, value);  // 64bit OS
printf(“%lld”, value); // 32bit OS

跨平台的做法:
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#undef __STDC_FORMAT_MACROS
printf(“%” PRId64 “\n”, value);

volatile 关键字

volatile的作用: 作为指令关键字,确保本条指令不会因编译器的优化而省略,且要求每次直接读值。简单地说就是防止编译器对代码进行优化。当要求使用volatile 声明的变量的值的时候,系统总是重新从它所在的内存读取数据,而不是使用保存在寄存器中的备份。即使它前面的指令刚刚从该处读取过数据,而且读取的数据立刻被保存。

 

线程ID

(1)、Linux中,每个进程有一个pid,类型pid_t,由getpid()取得。Linux下的POSIX线程也有一个id,类型 pthread_t,由pthread_self()取得,该id由线程库维护,其id空间是各个进程独立的(即不同进程中的线程可能有相同的id)。Linux中的POSIX线程库实现的线程其实也是一个进程(LWP),只是该进程与主进程(启动线程的进程)共享一些资源而已,比如代码段,数据段等。

(2)、有时候我们可能需要知道线程的真实pid。比如进程P1要向另外一个进程P2中的某个线程发送信号时,既不能使用P2的pid,更不能使用线程的pthread id,而只能使用该线程的真实pid,称为tid。

(3)、有一个函数gettid()可以得到tid,但glibc并没有实现该函数,只能通过Linux的系统调用syscall来获取。
return syscall(SYS_gettid)

 

__thread关键字

__thread,gcc内置的线程局部存储设施(每个线程有一份)

__thread只能修饰POD类型

POD类型(plain old data),与C兼容的原始数据,例如,结构体和整型等C语言中的类型是 POD 类型,但带有用户定义的构造函数或虚函数的类则不是

若不是POD数据类型,但也想作为线程局部存储,可以使用线程特定数据TSD

 

pthread_atfork()

 

#include <pthread.h>
int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));

pthread_atfork()在fork()之前调用,当调用fork时,内部创建子进程前在父进程中会调用prepare,内部创建子进程成功后,父进程会调用parent ,子进程会调用child。同样的流程,但在执行fork() 创建子进程之前,先执行prepare(), 将子线程加锁的mutex 解锁下,然后为了与doit() 配对,在创建子进程成功后,父进程调用parent() 再次加锁,这时父进程的doit() 就可以接着解锁执行下去。而对于子进程来说,由于在fork() 创建子进程之前,mutex已经被解锁,故复制的状态也是解锁的,所以执行doit()就不会死锁了。

 

pthread_once

pthread_once(&ponce_, &Singleton::init);

保证init函数只被调用一次,即只初始化一个对象。在init内部 value_ = new T();
atexit

::atexit(destroy);

在init 函数内注册destroy,在程序结束时会调用destroy,在destroy内部delete value_;

 

boost::shared_ptr的内存管理机制:

boost::shared_ptr的管理机制其实并不复杂,就是对所管理的对象进行了引用计数,当新增一个boost::shared_ptr对该对象进行管理时,就将该对象的引用计数加一;减少一个boost::shared_ptr对该对象进行管理时,就将该对象的引用计数减一,如果该对象的引用计数为0的时候,说明没有任何指针对其管理,才调用delete释放其所占的内存。

boost::shared_ptr的特点:

和前面介绍的boost::scoped_ptr相比,boost::shared_ptr可以共享对象的所有权,因此其使用范围基本上没有什么限制(还是有一些需要遵循的使用规则,下文中介绍),自然也可以使用在stl的容器中。另外它还是线程安全的,这点在多线程程序中也非常重要。

boost::shared_ptr的使用规则:

避免对shared_ptr所管理的对象的直接内存管理操作,以免造成该对象的重释放

shared_ptr并不能对循环引用的对象内存自动管理(这点是其它各种引用计数管理内存方式的通病)。

不要构造一个临时的shared_ptr作为函数的参数。
bind/function 

(1)头文件

bind函数#include <boost/bind.hpp>

function使用头文件#include <boost/function.hpp>

(2)功能

bind绑定一个函数及其参数.

function是类和模板的组合,它定义的对象可以指向一个函数(包装一个函数 ),类似一个函数指针。既可以直接指向一个函数也可以接收bind的返回值。

(3)返回值

bind返回一个函数对象。

function本身是一种类模板,可被看作声明的关键字。

2 用法

【bind】

一般用法:bind用于一般普通函数( 以非类、结构的成员函数 )具有多种形式,但用法简单。

用于类、结构的成员函数:bind用于成员函数时必须要在参数列表中指出成员函数在所属的类中的地址,成员函数所属对象,让bind知道此成员函数所属类地址和调用此成员函数的类对象。除了这两点额外的要求后,使用形式跟一般用法一致。

 

【function】

一般用法:function用于一般函数的情况下,只需要按照一般函数的 “返回值”,“参数列表( 参数列表用括号括起来,彼此用逗号隔开 )”来声明对象,然后指向对应的函数地址(函数名)用于成员函数:单用function来包装类的成员函数,需要按照函数 “返回值”,“类指针类型和参数列表(类指针型别和餐宿列表在括号中,彼此用逗号隔开)”来声明function对象。在调用被包装的函数时,必须要事先定义一个类对象将其地址传入,与声明function对象时的第一个类指针参数相对应。让function对象知道函数的所属地址及具体调用成员函数类对象。

 

【bind & function】

不管是针对一般的函数还是针对类成员函数,都不可以使用占位符来作为bind的参数,因为用function调用包装函数的时候会报参数不对应的错误。另外bind的返回一定要是一个函数地址而不是调用函数的形式。

在针对类成员函数的时候,function对象可以不再有类和对象的地址。因为bind已经将二者包装了。

二者的其它用法跟其单独使用时的规则大同小异。

2.1 bind

(1)bind 单用

void print( int i, int j )

{

cout <<i <<“\t” <<j<<“\n”;

}

 

[1]全参数绑定

bind(print, 3, 4)();

输出3       4

[2]部分参数绑定

bind( print, 3, _1)(4);//使用占位符给调用函数传参占个位置:传入4

输出3       4

[3]所有参数都不绑定

bind(print, _1, _2)(3, 4);

输出3       4

bind(print, * ,* );*表示参数,返回的是print函数,加在行尾加”()”表示调用print函数。

(2)bind应用于成员函数

bind在用于成员函数时,除了函数地址的重要性之外,还要知道具体是哪一个对象在调用类中的成员函数。如果是在类中的成员函数中调用另外一个成员函数这个对象可以被声明为this。

class Myfun

{

public:

void print( int i, int j )

{

cout << i<< “\t” << j << “\n”;

}

};

 

Myfun f;

boost::bind(&Myfun::print,f, 3, 4)();

 

要用bind绑定类类中的成员函数时,第一个参数表示成员函数的所在类的地址,第二个参数表示具体调用此成员函数的对象。后面的参数跟bind用于一般函数的用法一致。

 

2.2 function

(1)function应用于一般的函数

针对于一般设计的函数( 非类和结构体中的成员函数 )来说,function指向一个函数的使用形式为:

若函数定义的形式为:type fun_name( type1 i, type2  j){…}

则使用function指向此函数:function<type(type1 i, type2 j)> tf;

tf=fun_name;

调用函数:tf( 1, 2 );

function模板内”<>”所要使用的类型要和函数的一致:type表示所指函数的返回值类型,type1,type2是所指函数参数的类型。

void  print( int i, int j )

{

cout << i << “\t” << j <<“\n”;

}

 

boost::function<void(inti, int j)> tf;

tf =print;

tf(3, 4);

输出3       4

(2)function应用于成员函数

要使用function指向一个类的成员函数时,不管是在指向此成员函数还是调用此成员函数都要让function对象知道其地址(声明function对象时就声明了地址部分)。调用成员函数时还只能调用某一个对象的成员函数。

class Myfun

{

public:

void print( int i, int j )

{

cout << i<< “\t” << j << “\n”;

}

};

 

boost::function<void(Myfun*,int i, int j)> tf;

tf =&Myfun::print;

Myfun f;

tf(&f::print,3, 4);

输出3       4

function应用直接应用于类的成员函数时,声明时要声明对应成员函数类的指针对象,在调用时再将定义的类对象的地址传入

 

2.3bind & function联用

(1)普通函数(非成员函数)

对于普通函数,bind绑定函数全部参数或者全部参数缺省用占位符代替的情况都可以和function连用。不能在bind绑定函数时使用占位符来缺省部分参数,然后再和function连用,在bind内使用占位符时,如果在bind绑定函数后面补齐参数则与function对象的类型不匹配,如果在使用function对象时补齐参数,则编译器会报函数参数不一致的错误。

 

(2)用于成员函数

class Myfun

{

public:

void print( int i, int j )

{

cout << i<< “\t” << j << “\n”;

}

};

………

boost::function<void(int i, int j)> tf;

Myfun f;

tf = boost::bind(&Myfun::print, f, 3, 4);

tf(3, 4);

 

__thread关键字

__thread是GCC内置的线程局部存储设施,存取效率可以和全局变量相比。__thread变量每一个线程有一份独立实体,各个线程的值互不干扰。可以用来修饰那些带有全局性且值可能变,但是又不值得用全局变量保护的变量。

__thread使用规则:只能修饰POD类型(类似整型指针的标量,不带自定义的构造、拷贝、赋值、析构的类型,二进制内容可以任意复制memset,memcpy,且内容可以复原),不能修饰class类型,因为无法自动调用构造函数和析构函数,可以用于修饰全局变量,函数内的静态变量,不能修饰函数的局部变量或者class的普通成员变量,且__thread变量值只能初始化为编译器常量(值在编译器就可以确定const int i=5,运行期常量是运行初始化后不再改变const int i=rand()).

 

boost::noncopyable

class noncopyable的基本思想是noncopyable把复制构造函数和复制赋值函数做成了private,这就意味着除非子类定义自己的copy构造和赋值函数,否则在子类没有定义的情况下,外面的调用者是不能够通过赋值和copy构造等手段来产生一个新的子类对象的。

Tcp_nodelay

只要发送数据就立马发出去,不管数据包的大小。

TCP_NODELAY 选项

设置该选项: public void setTcpNoDelay(boolean on) throws SocketException
读取该选项: public boolean getTcpNoDelay() throws SocketException
默认情况下, 发送数据采用Negale 算法. Negale 算法是指发送方发送的数据不会立即发出,

而是先放在缓冲区, 等缓存区满了再发出. 发送完一批数据后, 会等待接收方对这批数据的回应,

然后再发送下一批数据. Negale 算法适用于发送方需要发送大批量数据, 并且接收方会及时作出

回应的场合, 这种算法通过减少传输数据的次数来提高通信效率.

如果发送方持续地发送小批量的数据, 并且接收方不一定会立即发送响应数据, 那么Negale算法会使发送方运行很慢. 对于GUI 程序, 如网络游戏程序(服务器需要实时跟踪客户端鼠标的移动), 这个问题尤其突出. 客户端鼠标位置改动的信息需要实时发送到服务器上, 由于Negale 算法采用缓冲, 大大减低了实时响应速度, 导致客户程序运行很慢.

TCP_NODELAY和TCP_CORK

这里了解一下问题的背景就好理解了[不考虑滑动窗口加入,只是说packet的组织]
1.历史上TCP是每发送一次包等待一个ACK然后下一个

2.但是在一些交互式应用下比如Telnet,结果就是我们每按一次键就会发送一个packet.每一个字

符配一个TCP头效率不高,那个Nagle算法出来了。发送方法送数据A时然后再等待接受方的ACK时,

积累本地收集到的所有TCP数据包然后一次性发送。但是很明显Nagle算法不利于交互式情景

3.但是现代应用下面还是存在交互式应用的,所以有时候我们需要关闭Nagle那么可以设置

TCP_NODELAY

4.但是Nagle组织包的长度是由系统决定的,有时候我们知道我们会每个1分钟产生1字节,共1000

字节。如果完全由Nagle算法来发送的话,可能还是会1字节1字节发送[这是一种极端情况,假设返

回ACK时间不是很长]。这个时候首先设置TCP_CORK能够阻塞住TCP[尽量阻塞住],等我们write完

1000字节之后,取消TCP_CORK,这个时候就能够将1000字节一次发出
TCP_NODELAY和TCP_CORK都是禁用Nagle算法,只不过NODELAY完全关闭而TCP_CORK完全由自己决定

发送时机。Linux文档上说两者不要同时设置。

 

linux新的API signalfd、timerfd、eventfd使用说明

三种新的fd加入linux内核的的版本:

signalfd:2.6.22

timerfd:2.6.25

eventfd:2.6.22

三种fd的意义:

signalfd:传统的处理信号的方式是注册信号处理函数;由于信号是异步发生的,要解决数据的并发访问,可重入问题。signalfd可以将信号抽象为一个文件描述符,当有信号发生时可以对其read,这样可以将信号的监听放到select、poll、epoll等监听队列中。

timerfd:可以实现定时器的功能,将定时器抽象为文件描述符,当定时器到期时可以对其read,这样也可以放到监听队列的主循环中。

eventfd:实现了线程之间事件通知的方式,eventfd的缓冲区大小是sizeof(uint64_t);向其write可以递增这个计数器,read操作可以读取,并进行清零;eventfd也可以放到监听队列中,当计数器不是0时,有可读事件发生,可以进行读取。

三种新的fd都可以进行监听,当有事件触发时,有可读事件发生。

signalfd涉及API:

#include <sys/signalfd.h>

int signalfd(int fd, const sigset_t *mask, int flags);

参数fd:如果是-1则表示新建一个,如果是一个已经存在的则表示修改signalfd所关联的信号;

参数mask:信号集合;

参数flag:内核版本2.6.27以后支持SFD_NONBLOCK、SFD_CLOEXEC;

成功返回文件描述符,返回的fd支持以下操作:read、select(poll、epoll)、close

timerfd涉及的API

#include <sys/timerfd.h>

int timerfd_create(int clockid, int flags);

int timerfd_settime(int fd, int flags,

const struct itimerspec *new_value,

struct itimerspec *old_value);

int timerfd_gettime(int fd, struct itimerspec *curr_value);

[cpp] view plaincopy

 

timerfd_create:创建一个timerfd;返回的fd可以进行如下操作:read、select(poll、epoll)、close

timerfd_settime:设置timer的周期,以及起始间隔

timerfd_gettime:获取到期时间。

[cpp] view plaincopy

 

函数参数中数据结构如下:

struct timespec

{

time_t tv_sec;                /* Seconds */

long   tv_nsec;               /* Nanoseconds */

};

 

struct itimerspec

{

struct timespec it_interval;  /* Interval for periodic timer */

struct timespec it_value;     /* Initial expiration */

};

eventfd涉及API:

#include <sys/eventfd.h>

int eventfd(unsigned int initval, int flags);

创建一个eventfd,这是一个计数器相关的fd,计数器不为零是有可读事件发生,read以后计数器清零,write递增计数器;返回的fd可以进行如下操作:read、write、select(poll、epoll)、close

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

您可以使用这些HTML标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">