Cpp on ZRJ | 学习笔记

c++11 thread

Tue, 24 Apr 2018 10:01:32 +0800

关于 c++11 的线程库，我们有如下几个问题：

可否不传参数
可否传递多个参数
可否传递 const 参数
可否传递引用参数
可否传递 const 引用参数
std::thread 结构可否放入容器
std::thread 可否在类内部使用

针对以上问题，我们先来看一个标准的 c++11 线程库要怎么使用：

#include <stdio.h>
#include <thread>

void f(int a) {
    printf("%d\n", a);
}

int main() {
    printf("hello world\n");
    std::thread t(f, 1);
    t.join();
    return 0;
}

>g++ test_thread.cpp -std=c++11 -pthread && ./a.out
hello world
1

然后试了一下不传参数，是可以的；多个参数，也是可以的；const 参数也是可以的

当试到传引用的时候，需要这么写才可以

#include <stdio.h>
#include <thread>
#include <string>

void f(int a, std::string& b) {
    printf("%d\n%s\n", a, b.c_str());
    b = "456";
}

int main() {
    printf("hello world\n");
    std::string str = "123";
    std::thread t(f, 1, std::ref(str));
    t.join();
    printf("%s\n", str.c_str());
    return 0;
}

>g++ test_thread.cpp -std=c++11 -pthread && ./a.out
hello world
1
123
456

然后 const 引用也是可以的

容器中也可以放，但是取出的时候只能取出引用，而不能取出值

#include <stdio.h>
#include <thread>
#include <string>
#include <vector>

void f(int a, const std::string& b) {
    printf("%d\n%s\n", a, b.c_str());
}

int main() {
    printf("hello world\n");
    std::string str = "123";
    std::vector<std::thread> vecT;
    vecT.push_back(std::thread(f, 1, std::ref(str)));
    std::thread& t = vecT[0];
    t.join();
    printf("%s\n", str.c_str());
    return 0;
}

>g++ test_thread.cpp -std=c++11 -pthread && ./a.out
hello world
1
123
123

最后，在类中使用的话，像这么写的话

#include <stdio.h>
#include <thread>
#include <string>
#include <vector>

class TestClass {
public:
    void f(int a, const std::string& b) {
        printf("%d\n%s\n", a, b.c_str());
    }

    void r() {
        printf("hello world\n");
        std::string str = "123";
        std::vector<std::thread> vecT;
        vecT.push_back(std::thread(f, 1, std::ref(str)));
        std::thread& t = vecT[0];
        t.join();
        printf("%s\n", str.c_str());
    }
};

int main() {
    TestClass testClass;
    testClass.r();
    return 0;
}

是会报错的

>g++ test_thread.cpp -std=c++11 -pthread && ./a.out
test_thread.cpp: In member function ‘void TestClass::r()’:
test_thread.cpp:16:55: error: no matching function for call to ‘std::thread::thread(<unresolved overloaded function type>, int, std::reference_wrapper<std::basic_string<char> >)’
         vecT.push_back(std::thread(f, 1, std::ref(str)));
                                                       ^
test_thread.cpp:16:55: note: candidates are:
In file included from test_thread.cpp:2:0:
/usr/local/include/c++/4.8.2/thread:133:7: note: std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (TestClass::*)(int, const std::basic_string<char>&); _Args = {int, std::reference_wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >}]
       thread(_Callable&& __f, _Args&&... __args)
       ^
/usr/local/include/c++/4.8.2/thread:133:7: note:   no known conversion for argument 1 from ‘<unresolved overloaded function type>’ to ‘void (TestClass::*&&)(int, const std::basic_string<char>&)’
/usr/local/include/c++/4.8.2/thread:128:5: note: std::thread::thread(std::thread&&)
     thread(thread&& __t) noexcept
     ^
/usr/local/include/c++/4.8.2/thread:128:5: note:   candidate expects 1 argument, 3 provided
/usr/local/include/c++/4.8.2/thread:122:5: note: std::thread::thread()
     thread() noexcept = default;
     ^
/usr/local/include/c++/4.8.2/thread:122:5: note:   candidate expects 0 arguments, 3 provided

搜了一下，看到 stackoverflow 上有人说， https://stackoverflow.com/questions/13888453/stdthread-unresolved-overloaded-function-type-error?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa

The problem is that a member function can’t be called without an object. Provide a pointer to this so that the current object is used:

thread t(&ThreadClass::myThread, this, 10); You could use an instance of any ThreadClass object, but in your case, it seems this is the right thing to do.

NOTE: Remember you need a reference to the created thread so that you can do a join() later on.

所以其实是类的成员函数中，隐含了第一个参数是一个 this 指针的原因

#include <stdio.h>
#include <thread>
#include <string>
#include <vector>

class TestClass {
public:
    void f(int a, const std::string& b) {
        printf("%d\n%s\n", a, b.c_str());
    }

    void r() {
        printf("hello world\n");
        std::string str = "123";
        std::vector<std::thread> vecT;
        vecT.push_back(std::thread(&TestClass::f, this, 1, std::ref(str)));
        std::thread& t = vecT[0];
        t.join();
        printf("%s\n", str.c_str());
    }
};

int main() {
    TestClass testClass;
    testClass.r();
    return 0;
}

改写成这样，就可以了

>g++ test_thread.cpp -std=c++11 -pthread && ./a.out
hello world
1
123
123

那很自然的，会接着一个问题，就是这个 f 能否是一个私有函数呢

试了一下，会发现，答案是可以的

leetcode Hamming Distance

Tue, 30 May 2017 10:37:37 +0800

https://leetcode.com/problems/hamming-distance/

盲敲，一遍过，:)

class Solution {
public:
    int hammingDistance(int x, int y) {
        int res = x ^ y;
        int cnt = 0;
        while (res) {
            if (res % 2) {
                cnt++;
            }
            res /= 2;
        }
        return cnt;
    }
};

获取当前机器 IP

Sat, 10 Oct 2015 15:13:50 +0800

std::string GetLocalIP()         
{        
    struct ifreq req; 
    int sock_fd; 
    char szLocalIP[16]= {0};
    string strLocalIP="";

    sock_fd = socket(AF_INET,SOCK_STREAM,0);
    if(sock_fd < 0)
        return strLocalIP; 
                         
    snprintf(req.ifr_name,IFNAMSIZ,"eth1");
    if(ioctl(sock_fd,SIOCGIFADDR,(char*)&req) < 0)
    {
        close(sock_fd);
        return strLocalIP;
    }
     
    snprintf(szLocalIP,sizeof(szLocalIP)-1,inet_ntoa(((struct sockaddr_in*)(&req.ifr_addr))->sin_addr));
    close(sock_fd);
    strLocalIP=szLocalIP;
    return strLocalIP; 
}

std::string getCurrentIP() {
    const char* pSzIpAddr = "0.0.0.0";
    char szIpAddrBuffer[32] = {0};
    struct ifaddrs* pIfAddrs;
    if (getifaddrs(&pIfAddrs) == 0)
    {
        for (struct ifaddrs* pIfAddr = pIfAddrs; pIfAddr; pIfAddr = pIfAddr->ifa_next)
        {
            if (pIfAddr->ifa_addr == NULL || !(pIfAddr->ifa_flags & IFF_UP) || strncmp(pIfAddr->ifa_name, "eth1", strlen("eth1")) != 0)
            {
                continue;
            }
            if (inet_ntop(pIfAddr->ifa_addr->sa_family, &((struct sockaddr_in *)pIfAddr->ifa_addr)->sin_addr, szIpAddrBuffer, sizeof(szIpAddrBuffer)))
            {   
                pSzIpAddr = szIpAddrBuffer;
                break;                
            }
        }
        freeifaddrs(pIfAddrs);
    }
    return std::string(pSzIpAddr);
}

unix domain socket dgram

Tue, 06 Oct 2015 12:45:18 +0800

大体上参考这里，http://philherlihy.com/unix-domain-sockets-datagram/

改动之后如下

服务端

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

char * server_filename = "/tmp/socket-server";

int main(void)
{
    int s = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (s == -1) {
        perror("socket server");
        exit(1);
    }
    
    struct sockaddr_un srv_un = {0};
    srv_un.sun_family = AF_UNIX;
    strncpy(srv_un.sun_path, server_filename, sizeof(srv_un.sun_path));

    unlink(server_filename);
    if (bind(s, (struct sockaddr *)&srv_un, sizeof(srv_un)) == -1) {
        perror("bind server");
        exit(1);
    }

    for(;;) {
        struct sockaddr_un cli_addr = {0};
        socklen_t cli_addr_len = sizeof(cli_addr);
        
        int msg;

        int recv_size = recvfrom(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        if (recv_size < 0) {
            perror("recvfrom");
            break;
        }       
        printf("recv %d\n", msg);
        
        msg *= 2;
        int sendto_size = sendto(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, sizeof(cli_addr));
        if (sendto_size < 0) {
            perror("sendto");
            return -1;
        }       
        printf("send %d\n", msg); 
    }

    close(s);
    unlink(server_filename);

    return 0;
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

char * server_filename = "/tmp/socket-server";
char * client_filename = "/tmp/socket-client";

int main(void)
{
    int s = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (s == -1) {
        perror("socket server");
        exit(1);
    }
    
    {
        struct sockaddr_un cli_un = { 0 };
        cli_un.sun_family = AF_UNIX;
        strncpy(cli_un.sun_path, client_filename, sizeof(cli_un.sun_path));
        
        unlink(client_filename);
        if (bind(s, (struct sockaddr *)&cli_un, sizeof(cli_un)) == -1) {
            perror("bind client");
            exit(1);
        }
    }
    
    {
        struct sockaddr_un srv_un = {0};
        srv_un.sun_family = AF_UNIX;
        strncpy(srv_un.sun_path, server_filename, sizeof(srv_un.sun_path));

        int msg = 1006;
        int sendto_size = sendto(s, &msg, sizeof(msg), 0, (struct sockaddr*)&srv_un, sizeof(srv_un));
        if (sendto_size < 0) {
            perror("sendto");
            return -1;
        }   
        printf("send %d\n", msg);
    }
    
    {
        struct sockaddr_un cli_un = { 0 };
        socklen_t cli_len = sizeof(cli_un);
        
        int msg;
        int recv_size = recvfrom(s, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_un, &cli_len);
        if (recv_size < 0) {
            perror("recvfrom");
            return -1;
        }   
        printf("recv %d\n", msg); 
    }
    
    close(s);
    unlink(client_filename);
    
    return 0;
}

条件变量的用法和封装

Mon, 10 Aug 2015 15:56:39 +0800

对条件变量的用法的说明可以见这里，http://www.wuzesheng.com/?p=1668，写的不错，看一个裸写的无封装的用法如下：

#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <queue>
#include <string>

#define  _PRINTF_(format, ...) printf("[%s][%05ld] " format " [%s::%s::%d]\n", getdatetimestr(), syscall(__NR_gettid), ##__VA_ARGS__, __FILE__, __FUNCTION__, __LINE__)

char* getdatetimestr() {
    static char datetimestr[32] = {0};
    static time_t last_update_time = 0;
    struct timeval tv = {0};
    gettimeofday(&tv, NULL);
    time_t nowtime = tv.tv_sec;
    if (nowtime != last_update_time) {
        last_update_time = nowtime;
        struct tm nowtm = {0};
        localtime_r(&nowtime, &nowtm);
        strftime(datetimestr, sizeof(datetimestr), "%Y-%m-%d %H:%M:%S", &nowtm);
    }
    snprintf(datetimestr+19, sizeof(datetimestr)-19, ".%06ld", tv.tv_usec);
    return datetimestr;
}

std::queue<std::string> task_queue;
pthread_mutex_t mutex_t = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_t = PTHREAD_COND_INITIALIZER;

void* thread_func1(void*) {
	_PRINTF_("producer");
	while (1) {
		//int sleep_sec = rand() % 5;
		//_PRINTF_("sleep %d sec", sleep_sec);
		//sleep(sleep_sec);
		
		_PRINTF_("waiting for mutex_t");
		pthread_mutex_lock(&mutex_t);
		std::string datetimestr = getdatetimestr();
		task_queue.push(datetimestr);
		_PRINTF_("put %s queue size %lu", datetimestr.c_str(), task_queue.size());
		pthread_cond_signal(&cond_t);
		pthread_mutex_unlock(&mutex_t);
	}	
	return NULL;
}

void* thread_func2(void* args) {
	char* indent = (char*)args;
	_PRINTF_("%s" "customer", indent);
	while (1) {
		//int sleep_sec = rand() % 5;
		//_PRINTF_("%s" "sleep %d sec", indent, sleep_sec);
		//sleep(sleep_sec);		
		
		_PRINTF_("%s" "waiting for mutex_t", indent);
		pthread_mutex_lock(&mutex_t);
		while (task_queue.empty()) {
			pthread_cond_wait(&cond_t, &mutex_t);
		}
		std::string datetimestr = task_queue.front();
		_PRINTF_("%s" "got %s queue size %lu", indent, datetimestr.c_str(), task_queue.size());
		task_queue.pop();
		pthread_mutex_unlock(&mutex_t);
	}	
	return NULL;
}

int main() {
	_PRINTF_("start");
	
	srand(time(NULL));
	
	pthread_t thread_t1 = {0};
	if (pthread_create(&thread_t1, NULL, thread_func1, NULL) != 0) {
		_PRINTF_("%m");
		return -1;
	}
	_PRINTF_("create thread 1 success");
	
	pthread_t thread_t21 = {0};
	char* indent21 = "\t";
	if (pthread_create(&thread_t21, NULL, thread_func2, (void*)indent21) != 0) {
		_PRINTF_("%m");
		return -1;
	}
	_PRINTF_("create thread 2 success");	
	
	pthread_t thread_t22 = {0};
	char* indent22 = "\t\t";
	if (pthread_create(&thread_t22, NULL, thread_func2, (void*)indent22) != 0) {
		_PRINTF_("%m");
		return -1;
	}
	_PRINTF_("create thread 22 success");	
	
	pthread_t thread_t23 = {0};
	char* indent23 = "\t\t\t";
	if (pthread_create(&thread_t23, NULL, thread_func2, (void*)indent23) != 0) {
		_PRINTF_("%m");
		return -1;
	}
	_PRINTF_("create thread 23 success");
	
	pthread_join(thread_t1, NULL);
	pthread_join(thread_t21, NULL);
	pthread_join(thread_t22, NULL);
	pthread_join(thread_t23, NULL);
	
	_PRINTF_("end");
	
	return 0;
}

36 进制

Fri, 07 Aug 2015 17:30:39 +0800

看到同事桌上有一份面试题，有一个 36 进制运算的题目，手贱敲了一下，不调真的不好做啊

#include <stdio.h>
#include <string>
#include <algorithm>
#include <math.h>

int convert_36_10(std::string strNum) {
	std::reverse(strNum.begin(), strNum.end());
	int n = 0;
	for (int i = 0; i < strNum.size(); i++) {		
		char c = strNum[i];
		if (c >= '0' && c <= '9') {
			n += (c - '0') * pow(36.0, i);
		} else if (c >= 'A' && c <= 'Z') {
			n += (10 + c - 'A') * pow(36.0, i);
		}
	}
	return n * ((strNum[strNum.size() - 1] == '-') ? -1 : 1);
}

std::string convert_10_36(int n) {
	if (n == 0) {
		return "0";
	}
	std::string strNum;
	int s = n > 0;
	n = abs(n);
	while (n) {
		int m = n % 36;
		char c = '-';
		if (m < 10) {
			c = m + '0';
		} else {
			c = m-10 + 'A';
		}
		strNum = c + strNum;
		n /= 36;
	}
	return s ? strNum : "-"+strNum;
}

std::string add(std::string strNum1, std::string strNum2) {
	int n1 = convert_36_10(strNum1);
	int n2 = convert_36_10(strNum2);
	return convert_10_36(n1 + n2);
}

std::string min(std::string strNum1, std::string strNum2) {
	int n1 = convert_36_10(strNum1);
	int n2 = convert_36_10(strNum2);
	return convert_10_36(n1 - n2);
}

int main() {
	while (1) {
		char szNum1[16] = {0}, szNum2[16] = {0};
		scanf("%s%s", szNum1, szNum2);
		printf("%s + %s = %s\n", szNum1, szNum2, add(szNum1, szNum2).c_str());
		printf("%s - %s = %s\n", szNum1, szNum2, min(szNum1, szNum2).c_str());
	}	
	return 0;
}

netty 初窥

Fri, 01 May 2015 16:33:43 +0800

先说结论，总体感觉很好，比 cpp 上的 nio 框架好。

缘起是一个同学来问 java web 的问题，帮他调了一下，两年没怎么碰过 java web 的东西了，各种生疏，而且在调试的过程中，也再次感觉到 java 这个东西实在不适合做 web，一个是重，ssh 框架一上来就给人压得喘不过气的感觉，新增一个功能，要 spring struts 里面 xml 各种配，访问一下数据库，需要 hibernate 里面一层层的 dao，看着就累，就算不用 ssh，自己写 servlet，也是各种繁琐，而且还不方便调试，做个什么改动，还要重启一下 web 容器，tomcat 也不是什么好东西，本身也复杂，总而言之，在做 web 这个事情上，跟动态脚本语言一比，几乎没有任何优势，唯一的优势可能就是效率？我宁可不要这个效率，反正量上来了最终瓶颈都是卡在数据库这块，逻辑层再快也没用。

不过转念一想到 netty，这个 java 社区里面著名的 nio 框架，想着以前都是只闻其声未见其人，趁着 eclipse 装着，也就是尝试了一把，整体下来的感觉非常好，相比 cpp 上自己的一些 nio 框架和一些自己写的 nio 框架，主要体现在以下一些方面：

标准规范，相比起来，cpp 上 nio 框架，品种繁多，挑的人眼花缭乱，libevent libev libuv，连名字都长得差不多，但是里面各种概念各种思想各种实现又有差别，在选择成本上就大了很多，再者这些框架，例如 libevent 来说，虽说是个 cpp 框架，但是 c 的味道还是很重，就显得不够干净利落，java 就好多了，社区中基本就以 netty 为事实上的标准，不要烦心怎么选，闭着眼睛用就行了。
概念清晰，相比起来，libevent 之流的框架，概念绕来绕去，cpp 的 nio 框架里面，除了 muduo 算是概念比较清晰的以外，其他的，我觉得不太好上手理解，而对于业务来说，能快速上手，能投入开发，才是王道，我们用一个框架不是为了来学习他的内部概念，而是为了来上线业务的，（虽然说用到后期，理解其内部概念也很重要，不过这是后话了），相比之下，netty 的概念就很清晰，channel，handler 的封装非常明了，这点从样例的 echo server 的代码，甚至从日志中，都能看的出来，先来看日志

2015-5-1 15:53:35 io.netty.util.internal.PlatformDependent <clinit>
信息: Your platform does not provide complete low-level API for accessing direct buffers reliably. Unless explicitly requested, heap buffer will always be preferred to avoid potential system unstability.
2015-5-1 15:53:35 io.netty.handler.logging.LoggingHandler channelRegistered
信息: [id: 0x7d92c9d5] REGISTERED
2015-5-1 15:53:35 io.netty.handler.logging.LoggingHandler bind
信息: [id: 0x7d92c9d5] BIND(0.0.0.0/0.0.0.0:8007)
2015-5-1 15:53:35 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0x7d92c9d5, /0.0.0.0:8007] ACTIVE
2015-5-1 15:53:37 io.netty.handler.logging.LoggingHandler logMessage
信息: [id: 0x7d92c9d5, /0.0.0.0:8007] RECEIVED: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007]
2015-5-1 15:53:37 io.netty.handler.logging.LoggingHandler channelRegistered
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] REGISTERED
2015-5-1 15:53:37 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] ACTIVE
2015-5-1 15:53:38 io.netty.handler.logging.LoggingHandler logMessage
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] RECEIVED(4B)
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 32 33 0a                                     |123.            |
+--------+-------------------------------------------------+----------------+
2015-5-1 15:53:38 io.netty.handler.logging.LoggingHandler logMessage
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] WRITE(4B)
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 32 33 0a                                     |123.            |
+--------+-------------------------------------------------+----------------+
2015-5-1 15:53:38 io.netty.handler.logging.LoggingHandler flush
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] FLUSH
2015-5-1 15:53:39 io.netty.handler.logging.LoggingHandler exceptionCaught
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] EXCEPTION: java.io.IOException: 远程主机强迫关闭了一个现有的连接。
java.io.IOException: 远程主机强迫关闭了一个现有的连接。
	at sun.nio.ch.SocketDispatcher.read0(Native Method)
	at sun.nio.ch.SocketDispatcher.read(SocketDispatcher.java:25)
	at sun.nio.ch.IOUtil.readIntoNativeBuffer(IOUtil.java:233)
	at sun.nio.ch.IOUtil.read(IOUtil.java:206)
	at sun.nio.ch.SocketChannelImpl.read(SocketChannelImpl.java:236)
	at io.netty.buffer.UnpooledHeapByteBuf.setBytes(UnpooledHeapByteBuf.java:256)
	at io.netty.buffer.AbstractByteBuf.writeBytes(AbstractByteBuf.java:881)
	at io.netty.channel.socket.nio.NioSocketChannel.doReadBytes(NioSocketChannel.java:241)
	at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:119)
	at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:511)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:468)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:382)
	at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:354)
	at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:111)
	at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run(DefaultThreadFactory.java:137)
	at java.lang.Thread.run(Thread.java:619)
2015-5-1 15:53:39 io.netty.handler.logging.LoggingHandler close
信息: [id: 0xb07295eb, /127.0.0.1:51027 => /127.0.0.1:8007] CLOSE()
2015-5-1 15:53:39 io.netty.handler.logging.LoggingHandler channelInactive
信息: [id: 0xb07295eb, /127.0.0.1:51027 :> /127.0.0.1:8007] INACTIVE
2015-5-1 15:53:39 io.netty.handler.logging.LoggingHandler channelUnregistered
信息: [id: 0xb07295eb, /127.0.0.1:51027 :> /127.0.0.1:8007] UNREGISTERED

这个是拿 nc 当客户端，做的一次连接，可以看到，TCP 连接的整个过程清晰明了，状态机一步步的转换清清楚楚，不看代码只看日志都能把流程理清

下面再来看对应的代码，官方的样例代码在 http://netty.io/4.0/xref/io/netty/example/echo/package-summary.html，但是其实这个代码写的并不好，对于一个担负着 helloworld 功能的 echo 服务来说，还给他搞什么 SSL 支持，实属画蛇添足，精简过后的代码，可以看这里：

package me.zrj;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public final class EchoServer {
	static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
	
	public static void main(String[] args) throws Exception {		
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup,workerGroup)
			.channel(NioServerSocketChannel.class)
			//.option(ChannelOption.SO_BACKLOG, 100)
			.handler(new LoggingHandler(LogLevel.INFO))
			.childHandler(new ChannelInitializer<SocketChannel>() {
				@Override
				public void initChannel(SocketChannel ch) throws Exception {
					ChannelPipeline p = ch.pipeline();					
					p.addLast(new LoggingHandler(LogLevel.INFO));
					p.addLast(new EchoServerHanlder());
				}
			});
			ChannelFuture f = b.bind(PORT).sync();
			f.channel().closeFuture().sync();
		} finally {
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}
}

package me.zrj;

import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

@Sharable
public class EchoServerHanlder extends ChannelInboundHandlerAdapter {
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) {
		ctx.write(msg);
	}
	
	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) {
		ctx.flush();
	}
	
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
		//cause.printStackTrace();
		ctx.close();
	}
}

话说前面的那个 static final int PORT = Integer.parseInt(System.getProperty(“port”, “8007”)); 的写法也真是脱了裤子放屁多此一举，不说也罢了。

调试方便，这个得益于 java vm 的跨平台，确实是有好处，相比开发 cpp，由于 linux 终端下没有好用的 IDE，所以开发的时候都是在 windows 下拿 visual studio 来写，完事了还要搭一个自动的同步环境，及时的把 windows 上的改动自动推到 linux 编译机上，再 make，然后才能跑起来，过冒烟测试，没问题了，才能往 svn 上交，来回一折腾，确实不方便，相比之下，java 可以直接在 windows 上写完了，跑起来，看着日志输出，爱怎么调怎么调，小农经济自给自足，说道日志输出，这里又要说两点，一个是虽然说，在多线程并发的环境下，日志几乎是唯一的 debug 手段，但是，在 cpp 上，是想单步也没的单步，拿 gdb 去单步的话，各种命令背的晕，而且想看个 STL 结构也是望洋兴叹基本等同于痴心妄想，visual studio 倒是可以很方便的单步，还带 STL 内容各种展开，但是奈何远水救不了近火，还是歇菜，然后另外一点就是再次要吐槽，cpp 社区里面，连个标准的日志库都没，这点相比 java 简直就是被甩几条街，这个还不止体现在日志这一个环节上，cpp 上连一个 string 的 spilt 都要自己动手才能丰衣足食，对于业务开发来说，要的是开发效率，不造轮子，string spilt 之流，应该是属于基本中的基本了。顺着这个再扯到 profiling 工具，java 不愧是企业级的开发平台，各种周边配套，服务完善，profiling 之类的任务基本就是衣来伸手饭来张口，而 cpp 虽然也有一些所谓的覆盖度，所谓的 profiling，但是奈何年迈，很多都是在没有多进程多线程混用的环境下可以工作的好，要是进程线程关系一复杂，就傻眼了，这点其实也难怪工具，主要是 cpp 里面 tricky 的写法太多，什么静态语法检查的事情，做起来确实是头疼，eclipse 就不一样了，IDE 可以做到对于代码的理解几乎是实时的，哪个地方 death code，哪个 package 是 import 了没用，哪里的 exception 抛了没接，分分钟给你指出来，不用过正式编译环节，很多问题在开发的时候顺手就解决掉了
易于部署，打包 JAR，往生产环境上一丢就完事了，java -jar **.jar 命令就跑起来，这年代的 linux 发行版，基本都自带 JRE，方便程度不亚于原生 cpp
后期维护，这个主要是涉及到团队协作，由于 java 天生就是一个适合工业化协作生产的语言，所以后期接手维护起来其实真是很有优势，这一点不仅体现在细微处，包括变量命名，缩进，括号，之类的编程规范上，而且还体现在稍微宏观的例如一个包进来了，怎么 decode，怎么业务逻辑处理，怎么回包，怎么日志，怎么落地，这些东西由于都有标准化工具，所以基本上换个不同的人来写，也都是八九不离十，能到达到不同的人写同一份代码的境界的，实现了同一个世界同一个梦想，one world one dream，同一批码农同样的代码的梦想

boost optional 以及 operator bool

Tue, 28 Apr 2015 18:18:20 +0800

boost 库有一个组件，叫做 optional，用来保存一些可有可无的成员变量，说明见这里，http://www.boost.org/doc/libs/1_58_0/libs/optional/doc/html/index.html，样例用法如下

#include <boost/optional.hpp>
#include <stdio.h>
#include <string>

int main() {
    boost::optional<std::string> name;
    if (name) {
        printf("name is %s\n", name->c_str());
    } else {
        printf("no name\n");
    }
    return 0;
}

注意两个点，一个是这个是指针调用 c_str()，另外就是，一个对象本身可以放在 if 里面去 test，这个之前还没想过，查了资料，发现在实现上是这么来搞的：

#include <boost/optional.hpp>
#include <stdio.h>
#include <string>

class Object {
public:
    std::string name;
    operator bool() {
        if (name.empty()) {
            return false;
        } else {
            return true;
        }
    }
};

int main() {
    Object obj;
    if (obj) {
        printf("obj is %s\n", obj.name.c_str());
    } else {
        printf("no obj...\n");
        obj.name = "foo";
        if (obj) {
            printf("obj has name now %s\n", obj.name.c_str());
        } else {
            printf("still no obj\n");
        }
    }
    return 0;
}

以前只是知道 operator+ 之类的，都不知道 operator bool() 这种

动态链接库中的全局变量

Thu, 26 Mar 2015 14:56:46 +0800

想给自己之前的日志库，加一个染色的功能

gcc 有一个自己的特性，叫 __thread，介绍可以看这里，https://gcc.gnu.org/onlinedocs/gcc-4.2.4/gcc/Thread_002dLocal.html，是可以用来修饰一个全局变量，从而让这个全局变量在每个线程都有一份拷贝，例子如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>

__thread int n = 0;

int ns[] = {1, 2};

void* thread_func(void *arg) {
    int tid = (int)syscall(__NR_gettid);
    printf("1, tid = %d, n = %d\n", tid, n);
    n = *((int*)arg);
    printf("2, tid = %d, n = %d\n", tid, n);
    while (1) {
        printf("3, tid = %d, n = %d\n", tid, n);
        sleep(1);
    }
}

int main() {
    for (int i = 0; i < sizeof(ns)/sizeof(ns[0]); i++) {        
        pthread_t tid;
        pthread_create(&tid, NULL, thread_func, &ns[i]);
        printf("thread %d created\n", tid);
    }
    while (1) {
        sleep(1);
    }
    return 0;
}

跑起来之后的输出是这样的

thread 1082132800 created
thread 1090525504 created
1, tid = 11508, n = 0
2, tid = 11508, n = 1
3, tid = 11508, n = 1
1, tid = 11509, n = 0
2, tid = 11509, n = 2
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2
3, tid = 11508, n = 1
3, tid = 11509, n = 2

用在日志库中，成为这个样子

#include <net/if.h>
#include <arpa/inet.h>
#include "logger.h"

__thread int m_iLoggerLogTraceOn;// 是否开启染色日志

int Logger::Init(eLogLevel level, const char* pLogFileDir, const char* pLogFileBaseName, uint32_t uiLogFileRollingSize, uint32_t uiMaxCharPerLine, uint32_t uiLogBufferLines)
{
    pthread_mutex_lock(&m_stInitLock);
    if (m_bInited || level == LOG_LEVEL_OFF)
    {
        pthread_mutex_unlock(&m_stInitLock);
        return 0;
    }

然后加了一个修改的接口

void Logger::setLogTraceOn(int iTraceOn)
{
    printf("set trace switch to %d\n", iTraceOn);
    m_iLoggerLogTraceOn = iTraceOn;
    printf("after set, iLoggerLogTraceOn(%p) is %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
}

在各个函数处也加了跟踪

void Logger::LogToMem(eLogLevel level, const char* format, ...)
{
    printf("trace on(%p) : %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
    if (m_bInited && (level >= m_eLevel || m_iLoggerLogTraceOn))
    {
        va_list args;
        va_start(args, format);            
        char *pWritePtr = m_pLogBufferMem+((__sync_add_and_fetch(&m_uiWriteLineCount, 1) % m_uiLogBufferLines) * m_uiMaxCharPerLine);
        vsnprintf(pWritePtr+1, m_uiMaxCharPerLine-2, format, args); 
        *(pWritePtr) = 1;
        va_end(args);
    }        
}

void Logger::LogToStdout(eLogLevel level, const char* format, ...)
{    
    printf("trace on(%p) : %d, tid is %d\n", &m_iLoggerLogTraceOn, m_iLoggerLogTraceOn, (int)syscall(__NR_gettid));
    if (m_bInited && (level >= m_eLevel || m_iLoggerLogTraceOn))
    {
        va_list args;
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
    }        
}

然后在业务中这么使用

if (pSession->strAppUser == "BAAEB881F489FC59")
    {
        Logger::setLogTraceOn(1);
        LOG_INFO("appuser match, turn logger trace on");
    }

然而，跑起来之后是这样的

set trace switch to 1
after set, iLoggerLogTraceOn(0x797bf0) is 1, tid is 9696
[2015-03-26 14:28:20] [INFO][            OnRequestData@          src/BusiObj.cpp,0136]  appuser match, turn logger trace on
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696
trace on(0x43b0693c) : 0, tid is 9696

注意到一个神奇的现象，同一个变量，在同一个线程里面，指针不一样了

考虑到之前做函数耗时测试，和代码覆盖度测试的时候，遇到过由于进程关系复杂（又多进程又线程的）引起的问题，考虑是否由于这个原因引起的问题，于是写了这么一个测试

来看这个：

t2.cpp

#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>

__thread int n = 0;

extern "C" {
    void busi(int arg) {    
        printf("1, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
        n = arg;
        printf("2, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
        while (1) {
            printf("3, tid = %d, n = %d\n", (int)syscall(__NR_gettid), n);
            sleep(1);
        }
    }
}

f1.cpp

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pthread.h>
#include <unistd.h>

int ns[] = {1, 2};

typedef void(*busi_func_ptr_t)(int);
busi_func_ptr_t busi_func_ptr ;

void* thread_func(void *args) {
   int arg = *((int*)args); 
   printf("0, arg = %d\n", arg);
   (*busi_func_ptr)(arg);
}

int main() {    
    int fork_ret = fork();
    if (fork_ret == 0) {
        void* dll = dlopen("./t2.so", RTLD_LAZY);
        if (dll == NULL) {
            printf("%s\n", dlerror());
            abort();
        }
        busi_func_ptr = (busi_func_ptr_t)dlsym(dll, "busi");
        char *err = dlerror();
        if (err != NULL) {
            printf("%s\n", err);
            abort();
        }
        for (int i = 0; i < sizeof(ns)/sizeof(ns[0]); i++) {
            pthread_t tid;
            pthread_create(&tid, NULL, thread_func, &ns[i]);
            printf("thread %d created\n", tid);
        }
        while (1) {
            sleep(1);
        }
        dlclose(dll);
    } else {
        printf("chid proc %d\n", fork_ret);
        while (1) {
            sleep(1);
        }
    }
    return 0;
}

makefile

all:
	g++ t2.cpp -O3 -shared -o t2.so -fPIC
	g++ f1.cpp -O3 -o f1 -ldl -pthread

makefile 带 O3 是为了跟实际情况保持一致

运行输出如下

thread 1082132800 created
chid proc 12856
thread 1090525504 created
0, arg = 1
1, tid = 12857, n = 0
2, tid = 12857, n = 1
3, tid = 12857, n = 1
0, arg = 2
1, tid = 12858, n = 0
2, tid = 12858, n = 2
3, tid = 12858, n = 2
3, tid = 12857, n = 1
3, tid = 12858, n = 2
3, tid = 12857, n = 1
3, tid = 12858, n = 2

看起来是没有问题的，又考虑到，我们的日志是先编译成一个静态的 lib.a 的库，然后在编译到 lib.so 的动态库中，最后由框架加载运行的，于是试了一下这么搞

我写了一个 test.cpp

public:

	//与tcpd的接口
	char * OnRequestData(const char * p_pcResData,
		                 int p_iResDataLen,
		                 int& p_iRetDataLen,
		                 int& p_iDataBufLen, 
		                 const char *p_pcHostIP, 
		                 const char * p_pcBusiBuf,
		                 int& piProcessedDataLen, int fd)
    {
        Logger::setLogTraceOn(1);
        printf("on request123\n");
        LOG_DEBUG("on request123");
        LOG_ERR("on request123");
        Logger::setLogTraceOn(0);
        printf("on request456\n");
        LOG_DEBUG("on request456");
        LOG_ERR("on request456");
        Logger::setLogTraceOn(1);
        printf("on request789\n");
        LOG_DEBUG("on request789");
        LOG_ERR("on request789");
        Logger::setLogTraceOn(0);
        return NULL;
    }
	
	int    OnDllDataUpdate(const char * p_pcDataBuf, int p_iDataBufLen) {}
	bool   FreeMemBlock(char * p_pcMemBlock, int p_iMemBlockLen) {
        return true;
    }
	bool   InitDllWithCfgFile(const char *p_pcCfgFileName) {
        printf("%s\n", p_pcCfgFileName);
        Logger::Init(Logger::LOG_LEVEL_INFO, "./", "stdout");
        Logger::setLogTraceOn(1);
    }

然后把含有日志库的通用组件的静态库和这个 test.cpp 放在同一个目录中，编出一个动态库

g++ test.cpp libcommontool.a -shared -o lib.so -fPIC

然后用 tcpd 去加载这个动态库

这个是 Init 函数打出来的

CALL DLL INIT INTERFACE
./main.cfg
set trace switch to 1
after set, iLoggerLogTraceOn(0x51be60) is 1, tid is 15719

这个是 OnRquest 函数打出来的

set trace switch to 1
after set, iLoggerLogTraceOn(0x52f280) is 1, tid is 15721
on request123
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0026]  on request123
set trace switch to 0
after set, iLoggerLogTraceOn(0x52f280) is 0, tid is 15721
on request456
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0030]  on request456
set trace switch to 1
after set, iLoggerLogTraceOn(0x52f280) is 1, tid is 15721
on request789
trace on(0x4090193c) : 0, tid is 15721
trace on(0x4090193c) : 0, tid is 15721
[2015-03-26 14:49:15][ERROR][            OnRequestData@                 test.cpp,0034]  on request789
set trace switch to 0
after set, iLoggerLogTraceOn(0x52f280) is 0, tid is 15721

于是到此就陷入了僵局，查资料说 gcc 在编译动态链接库的时候对全局变量的处理有一些特殊，看到这里，http://blog.csdn.net/zxh821112/article/details/8969541，还有，http://blog.csdn.net/yuyin86/article/details/10239479，http://bbs.chinaunix.net/thread-1620536-1-1.html，和这里，https://www.owent.net/2014/01/cpp%E5%8F%88%E4%B8%80%E5%9D%91-%E5%8A%A8%E6%80%81%E9%93%BE%E6%8E%A5%E5%BA%93%E4%B8%AD%E7%9A%84%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F.html，不过这些帖子在讨论，主要是集中在一个动态库被多个进程引用的时候的赋值问题，跟我们这个场景还不太一样

-—————–

2015-3-26 20:34:46 update http://lists.freebsd.org/pipermail/freebsd-hackers/2007-March/020057.html 这里有一篇，之前没发现

-——————–

2015-3-27 11:33:43 update 最后确认是编译器的问题，生产环境的编译器是 4.1.2 的老古董，换一个 gcc 4.8.2 问题就烟消云散了

(void)var 是在干嘛

Fri, 13 Mar 2015 17:24:56 +0800

最近在看 muduo 的代码，看到类似这样的写法：

size_t n = activeTimers_.erase(timer);
assert(n == 1); (void)n;

而且不止一处，于是就很好奇，这种 (void)var 是在干嘛，查了一下，这里说道，http://stackoverflow.com/questions/7354786/what-does-void-variable-name-do-at-the-beginning-of-a-c-function

It works around some compiler warnings. Some compilers will warn if you don’t use a function parameter. In such a case, you might have deliberately not used that parameter, not be able to change the interface for some reason, but still want to shut up the warning. That (void) casting construct is a no-op that makes the warning go away. Here’s a simple example using clang:

int f1(int a, int b) { (void)b; return a; }

int f2(int a, int b) { return a; } Build using the -Wunused-parameter flag and presto:

$ clang -Wunused-parameter -c -o example.o example.c example.c:7:19: warning: unused parameter ‘b’ [-Wunused-parameter] int f2(int a, int b) ^ 1 warning generated.

让人不得不感慨，cpp 的世界里欢乐多啊。。

历史评论

Jiangge Zhang (2015-03-19 18:20:21):

这也不是 C++ 特有问题嘛，想方设法绕过静态分析检查的总是有的…… Python 里有有人写 foo = foo 来绕过 lint 工具的 unused variable 警告。

17mon IP 解析代码 C++ 版

Sat, 27 Dec 2014 12:04:45 +0800

高春辉做了一个功德无量的事情，整理了一份高质量的 IP 库，http://tool.17mon.cn/ipdb.html，官方给出了 php 版本的解析函数，但是没有 c++ 的，倒是有人写了一个 php c 扩展，https://github.com/shukean/monip/blob/master/monip.c，不过太长了。。

于是自己写了个 c++ 的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#include <fstream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>

class IP17MON {
public:
    bool init(const std::string strPathToDataFile = "./17monipdb.dat") {
        printf("Opening %s\n", strPathToDataFile.c_str());
        std::ifstream ifDataFile(strPathToDataFile.c_str(), std::ios::binary);
        if (ifDataFile.is_open() == false) {
            printf("%m\n");
            return false;
        }
        vecDataFile.assign(std::istreambuf_iterator<char>(ifDataFile), std::istreambuf_iterator<char>());
        printf("Load %lu bytes success\n", vecDataFile.size());
        
        unsigned int uiIndexLen = 0;
        memcpy(&uiIndexLen, &vecDataFile[0], 4);
        uiIndexLen = ntohl(uiIndexLen);
        //printf("index len %u\n", uiIndexLen);
        pIPIndex = &vecDataFile[4];
        pIPData = &vecDataFile[uiIndexLen];
        
        return true;
    }
    std::string find(const std::string strIP) {        
        if (strIP.empty()) {
            return "";
        }
        
        struct sockaddr_in stSockAddrInet = {0};
        if(inet_aton(strIP.c_str(), &stSockAddrInet.sin_addr) == 0) {
            //printf("convert error\n");
            return "";
        }
        unsigned int uiIP = ntohl(stSockAddrInet.sin_addr.s_addr);
        //printf("ip %X\n", uiIP);
        
        int iFirst = atoi(strIP.c_str());
        
        int iStart = 0;
        memcpy(&iStart, pIPIndex+(iFirst*4), 4);
        //printf("start %d\n", iStart);
        
        int iMaxComLen = pIPData - pIPIndex - 1024 - 4;
        //printf("max compare len %d\n", iMaxComLen);
        
        int iIndexOffset = -1;
        unsigned char ucIndexLength = 0;
        for (iStart = iStart * 8 + 1024; iStart < iMaxComLen; iStart += 8) {
            unsigned int uiCurrIP = 0;
            memcpy(&uiCurrIP, pIPIndex+iStart, 4);
            uiCurrIP = ntohl(uiCurrIP);
            //printf("curr %u looking %u\n", uiCurrIP, uiIP);
            if (uiCurrIP >= uiIP) {
                iIndexOffset = 0;
                memcpy(&iIndexOffset, pIPIndex+iStart+4, 3);   
                memcpy(&ucIndexLength, pIPIndex+iStart+7, 1);  
                break;
            }
        }
        //printf("index offset %u\n", iIndexOffset);
        //printf("index length %u\n", ucIndexLength);
        
        if (iIndexOffset == -1) {
            return "";
        }
        
        std::string strRegion;
        char *pRegion = pIPData + iIndexOffset - 1024;
        strRegion.assign(pRegion, ucIndexLength);
        //printf("str region %s\n", strRegion.c_str());
        
        return strRegion;
    }
private:
    std::vector<char> vecDataFile;
    char *pIPIndex, *pIPData;
};

int main() {
    IP17MON oIP17MON;
    assert(oIP17MON.init());
    printf("%s -> %s\n", "14.17.22.40", oIP17MON.find("14.17.22.40").c_str());    
    return 0;
}

效率方面，在我 cpu e5300, ram 4g ddr2 800, os ubuntu 14.04 的机器上，大约是每秒 150 万次

fprintf 是线程安全的吗

Thu, 11 Sep 2014 09:42:46 +0800

以前一直担心在多线程环境下，多个线程同时调用 fprintf 往同一个 fp 写东西会不会出现交错的情况，昨天微博上问了问人，有提到 fprintf_unlocked，也说到 fprintf 是线程安全的，后来又查了一下，看到这里，http://stackoverflow.com/questions/11664434/how-fprintf-behavior-when-multi-threaded-and-multi-processed ，其中也有提到，fprintf 在多线程下是内部持有锁的

If you’re using a single FILE object to perform output on an open file, then whole fprintf calls on that FILE will be atomic, i.e. lock is held on the FILE for the duration of the fprintf call. Since a FILE is local to a single process’s address space, this setup is only possible in multi-threaded applications; it does not apply to multi-process setups where several different processes are accessing separate FILE objects referring to the same underlying open file. Even though you’re using fprintf here, each process has its own FILE it can lock and unlock without the others seeing the changes, so writes can end up interleaved. There are several ways to prevent this from happening:

Allocate a synchronization object (e.g. a process-shared semaphore or mutex) in shared memory and make each process obtain the lock before writing to the file (so only one process can write at a time); OR

Use filesystem-level advisory locking, e.g. fcntl locks or the (non-POSIX) BSD flock interface; OR

Instead of writing directly to the log file, write to a pipe that another process will feed into the log file. Writes to a pipe are guaranteed (by POSIX) to be atomic as long as they are smaller than PIPE_BUFbytes long. You cannot use fprintf in this case (since it might perform multiple underlying write operations), but you could use snprintf to a PIPE_BUF-sized buffer followed by write.

对 c++ unordered_map 源码的解析

Mon, 18 Aug 2014 17:54:25 +0800

主要尝试回答下面几个问题：

一般情况下，使用 hash 结构，需要有桶的概念，那么 unordered_map 是如何自动管理桶的，这个问题其实再细分的话是这样的：
初始的桶是如何设置的
当需要扩容的时候，是如何重新分布的
对于 string，unordered_map 的默认哈希函数是怎样的

代码位于 /usr/include/c++/4.1.2/tr1/，编译器版本比较老，在这个目录下，有这些文件

total 308K
-rw-r--r-- 1 root root 3.2K 2007-05-03 20:55 utility
-rw-r--r-- 1 root root 5.5K 2007-05-03 20:55 unordered_set
-rw-r--r-- 1 root root 5.8K 2007-05-03 20:55 unordered_map
-rw-r--r-- 1 root root 5.2K 2007-05-03 20:55 type_traits_fwd.h
-rw-r--r-- 1 root root  20K 2007-05-03 20:55 type_traits
-rw-r--r-- 1 root root 4.8K 2007-05-03 20:55 tuple_iterate.h
-rw-r--r-- 1 root root  11K 2007-05-03 20:55 tuple
-rw-r--r-- 1 root root  41K 2007-05-03 20:55 repeat.h
-rw-r--r-- 1 root root 1.9K 2007-05-03 20:55 ref_wrap_iterate.h
-rw-r--r-- 1 root root 2.0K 2007-05-03 20:55 ref_fwd.h
-rw-r--r-- 1 root root 2.3K 2007-05-03 20:55 mu_iterate.h
-rw-r--r-- 1 root root 2.0K 2007-05-03 20:55 memory
-rw-r--r-- 1 root root  63K 2007-05-03 20:55 hashtable
-rw-r--r-- 1 root root  28K 2007-05-03 20:55 functional_iterate.h
-rw-r--r-- 1 root root  36K 2007-05-03 20:55 functional
-rw-r--r-- 1 root root  24K 2007-05-03 20:55 boost_shared_ptr.h
-rw-r--r-- 1 root root 8.1K 2007-05-03 20:55 bind_repeat.h
-rw-r--r-- 1 root root 2.8K 2007-05-03 20:55 bind_iterate.h
-rw-r--r-- 1 root root 7.4K 2007-05-03 20:55 array

需要注意的是，unorder_map 和 unorder_set，其实都是一个封装而已，底下用的是 hashtable，所以分析也着重分析 hashtable

先来看一个典型的操作，[ ] 运算符，在 679 行附近，有这样的代码

template<typename K, typename Pair, typename Hashtable>
    typename map_base<K, Pair, extract1st<Pair>, true, Hashtable>::mapped_type&
    map_base<K, Pair, extract1st<Pair>, true, Hashtable>::
    operator[](const K& k)
    {
      Hashtable* h = static_cast<Hashtable*>(this);
      typename Hashtable::hash_code_t code = h->m_hash_code(k);
      std::size_t n = h->bucket_index(k, code, h->bucket_count());

      typename Hashtable::node* p = h->m_find_node(h->m_buckets[n], k, code);
      if (!p)
	return h->m_insert_bucket(std::make_pair(k, mapped_type()),
				  n, code)->second;
      return (p->m_v).second;
    }

可以看到，这是典型的 hash 操作的写法

先对 key 算出 hash code
找到这个 hash code 对应的桶
在这个桶里面，遍历去找这个 key 对应的节点
把节点返回

需要注意的是，如果找不到节点，不是返回空，而是会创建一个新的空白节点，然后返回这个空白节点，这里估计是受到返回值的约束，因为返回值声明了必须为一个引用，所以总得搞一个东西出来才能有的引用

接下来看初始化过程，gdb 跟踪代码可以发现，在 /usr/include/c++/4.1.2/tr1/unordered_map:86，有下面这样的代码，可以看到，初始化的桶大小，被写死为 10。

explicit
      unordered_map(size_type n = 10,
		    const hasher& hf = hasher(),
		    const key_equal& eql = key_equal(),
		    const allocator_type& a = allocator_type())
      : Base(n, hf, Internal::mod_range_hashing(),
	     Internal::default_ranged_hash(),
	     eql, Internal::extract1st<std::pair<const Key, T> >(), a)
      { }

但是，我们看一下下面这个代码的输出

#include <tr1/unordered_map>
#include <string>
#include <stdio.h>

int main() {
    std::tr1::unordered_map<std::string, int> m;
    printf("%d\n", m.bucket_count());
    return 0;
}

输出是 11。为什么呢，这个涉及到 rehash。他是初始化为 10，然后 rehash 为 11 了。

rehash 有两个问题，一个是判断什么时候需要 rehash，一个是怎么 rehash。

need_rehash 在 hasttable 的 614 附近：

inline std::pair<bool, std::size_t>
  prime_rehash_policy::
  need_rehash(std::size_t n_bkt, std::size_t n_elt, std::size_t n_ins) const
  {
    if (n_elt + n_ins > m_next_resize)
      {
	float min_bkts = (float(n_ins) + float(n_elt)) / m_max_load_factor;
	if (min_bkts > n_bkt)
	  {
	    min_bkts = std::max(min_bkts, m_growth_factor * n_bkt);
	    const unsigned long* const last = X<>::primes + X<>::n_primes;
	    const unsigned long* p = std::lower_bound(X<>::primes, last,
						      min_bkts, lt());
	    m_next_resize =
	      static_cast<std::size_t>(std::ceil(*p * m_max_load_factor));
	    return std::make_pair(true, *p);
	  }
	else
	  {
	    m_next_resize =
	      static_cast<std::size_t>(std::ceil(n_bkt * m_max_load_factor));
	    return std::make_pair(false, 0);
	  }
      }
    else
      return std::make_pair(false, 0);
  }

来看他是怎么做的，首先是用一个 m_max_load_factor 的因子来判断目前的容量需要多少个哈希桶，如果需要 rehash，那么使用素数表来算出新的桶需要多大。

素数表在 491 行附近：

template<int ulongsize>
    const unsigned long X<ulongsize>::primes[256 + 48 + 1] =
    {
      2ul, 3ul, 5ul, 7ul, 11ul, 13ul, 17ul, 19ul, 23ul, 29ul, 31ul,

初始的时候，m_max_load_factor(1), m_growth_factor(2), m_next_resize(0)，根据 std::lower_bound 来找到比 10 大的最小素数是 11，于是就分配为 11 个桶。

rehash 就很平淡无奇了，一个一个重算，然后重新填进去，没有什么特别的。

template<typename K, typename V,
	   typename A, typename Ex, typename Eq,
	   typename H1, typename H2, typename H, typename RP,
	   bool c, bool ci, bool u>
    void
    hashtable<K, V, A, Ex, Eq, H1, H2, H, RP, c, ci, u>::
    m_rehash(size_type n)
    {
      node** new_array = m_allocate_buckets(n);
      try
	{
	  for (size_type i = 0; i < m_bucket_count; ++i)
	    while (node* p = m_buckets[i])
	      {
		size_type new_index = this->bucket_index(p, n);
		m_buckets[i] = p->m_next;
		p->m_next = new_array[new_index];
		new_array[new_index] = p;
	      }
	  m_deallocate_buckets(m_buckets, m_bucket_count);
	  m_bucket_count = n;
	  m_buckets = new_array;
	}
      catch(...)
	{
	  // A failure here means that a hash function threw an exception.
	  // We can't restore the previous state without calling the hash
	  // function again, so the only sensible recovery is to delete
	  // everything.
	  m_deallocate_nodes(new_array, n);
	  m_deallocate_buckets(new_array, n);
	  m_deallocate_nodes(m_buckets, m_bucket_count);
	  m_element_count = 0;
	  __throw_exception_again;
	}
    }

然后就是 hash 函数了。hash 函数位于 /usr/include/c++/4.1.2/tr1/functional:1194，对于 std::string，用的是下面这种 hash 函数

template<>
    struct Fnv_hash<8>
    {
      static std::size_t
      hash(const char* first, std::size_t length)
      {
	std::size_t result = static_cast<std::size_t>(14695981039346656037ULL);
	for (; length > 0; --length)
	  {
	    result ^= (std::size_t)*first++;
	    result *= 1099511628211ULL;
	  }
	return result;
      }
    };

这个叫 FNV hash，http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function，FNV 有分版本，例如 FNV-1 和 FNV-1a，区别其实就是先异或再乘，或者先乘在异或，这里用的是 FNV-1a，为什么呢，维基里面说，The small change in order leads to much better avalanche characteristics，什么叫 avalanche characteristics 呢，这个是个密码学术语，叫雪崩效应，意思是说输入的一个非常微小的改动，也会使最终的 hash 结果发生非常巨大的变化，这样的哈希效果被认为是更好的。

tr1 的 unorderd_map

Thu, 24 Apr 2014 11:17:15 +0800

#include <tr1/unordered_map>
#include <stdio.h>
#include <string>

int main() {
    typedef std::tr1::unordered_map<std::string, int> HashMap;
    HashMap mapNumber;
    mapNumber["one"] = 1;
    mapNumber["two"] = 2;
    std::tr1::hash<std::string> hashFunc = mapNumber.hash_function();
    for (HashMap::const_iterator it = mapNumber.begin();
            it != mapNumber.end(); it++) {
        printf("%s(hash code: %d) -> %d\n", it->first.c_str(),
                hashFunc(it->first), it->second);
    }
    return 0;
}

two(hash code: 1149015817) -> 2
one(hash code: 566910127) -> 1

如果需要自定义类型，可以看这里，http://hi.baidu.com/wewe39/item/c342d5f48cb25d0ec6dc45a9

稍后做一下和 std::map 的查找效率对比

-————————-

2014-4-24 13:03:39 update

刚刚看了一下效率对比

#include <tr1/unordered_map>
#include <map>
#include <stdio.h>
#include <string>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

std::map<std::string, int> rbtreeMap;
std::tr1::unordered_map<std::string, int> hashMap;

void printtime() {
    struct timeval tm;
    gettimeofday(&tm, NULL);
    printf("%lu, %lu\n", tm.tv_sec, tm.tv_usec);
}

void initRbtreeMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        rbtreeMap[str] = r;
    }
    printf("rb tree map size %d\n", rbtreeMap.size());
}

void initHashMap(int init_count) {
    for (int i = 0; i < init_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        hashMap[str] = r;
    }
    printf("hash map size %d\n", hashMap.size());
}

void testRbtreeMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (rbtreeMap.find(str) == rbtreeMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("rb tree hit count %d miss count %d\n",
            hit, miss);
}

void testHashMap(int init_count, int test_count) {
    int hit = 0, miss = 0;
    for (int i = 0; i < test_count; i++) {
        int r = rand() % init_count;
        char str[16] = {0};
        snprintf(str, sizeof str, "%d", r);
        if (hashMap.find(str) == hashMap.end()) {
            miss++;
        } else {
            hit++;
        }
    }
    printf("hash tree hit count %d miss count %d\n",
            hit, miss);
}

int main() {
    srand(time(NULL));
    int init_count = 500 * 1000;
    printtime();
    initRbtreeMap(init_count);
    printtime();
    initHashMap(init_count);
    printtime();
    int test_count = 10 * 1000 * 1000;
    testRbtreeMap(init_count, test_count);
    printtime();
    testHashMap(init_count, test_count);
    printtime();
    return 0;
}

1398315723, 65363
rb tree map size 316072
1398315724, 33265
hash map size 316202
1398315724, 423226
rb tree hit count 6320750 miss count 3679250
1398315743, 283560
hash tree hit count 6323107 miss count 3676893
1398315748, 386742

tr1 的 bind 和 function

Fri, 18 Apr 2014 16:36:37 +0800

首先来看两个文章，function/bind的救赎（上），http://blog.csdn.net/myan/article/details/5928531，以boost::function和boost:bind取代虚函数，http://blog.csdn.net/solstice/article/details/3066268，前者讲背景和理论，后者讲实际操作和细节对比，读来酣畅淋漓，醍醐灌顶

这么好的东西，当然要想着怎么在现有的环境条件下用起来，没有 boost，但是幸运的是这东西已经进了 tr1，那么可以这么来

#include <stdio.h>
#include <tr1/functional>

using std::tr1::function;
using std::tr1::bind;
using std::tr1::placeholders::_1;

class Foo {
public:
    void methodA() {
        printf("method a\n");
    }
    void methodInt(int a) {
        printf("method int %d\n", a);
    }
};

class Bar {
public:
    void methodB() {
        printf("method b\n");
    }
};

int main() {
    Foo foo;
    function<void()> f1 = bind(&Foo::methodA, &foo);
    f1();

    Bar bar;
    f1 = bind(&Bar::methodB, &bar);
    f1();
    
    f1 = bind(&Foo::methodInt, &foo, 42);
    f1();
    
    function<void(int)> f2 = bind(&Foo::methodInt, &foo, _1);
    f2(53);
    
    return 0;
}

得到输出

method a
method b
method int 42
method int 53

真是好用，不过需要注意的一点就是带了 tr1/functional 这东西之后，编译速度明显下来了很多

-————————————————————-

2014-04-19 20:34:37 update

跟同学讨论之后，发现这个东西，其实可以这么来模拟

#include <stdio.h>

typedef void (*fun)(void *, int, int);    

class Foo
{
private:
    void add(int a, int b)
    {
	printf("%d\n", a+b);
    }
public:
    fun mybind()
    {
	fun f = (fun)&Foo::add;
	return f;
    }
};

int main(int argc, char **argv)
{
    Foo foo;    
    fun f = foo.mybind();
    f(&foo, 1, 2);
    return 0;
}

看，虽然 add 是个私有函数，但是我们可以把他偷换出来，在外面去调用，不过需要注意，这个代码编译是有警告的

历史评论

ZRJ (2014-04-18 16:46:01):

http://blog.csdn.net/jnu_simba/article/details/12944043 这个也不错

wanax (2014-04-21 12:11:04):

面向类设计的癌症赞

tian (2014-04-30 17:17:18):

VM_195_29_sles10_64:~/tmp> g++ –version g++ (GCC) 4.1.2 20070115 (prerelease) (SUSE Linux)

VM_195_29_sles10_64:~/tmp> g++ bind.cpp bind.cpp: In member function ‘void (* Foo::mybind())(void*, int, int)’: bind.cpp:15: error: converting from ‘void (Foo::)(int, int)’ to ‘void ()(void*, int, int)’ 最后的那段代码编译错误

ZRJ (2014-04-30 19:27:33):

确实，看来我之前是编译器老旧侥幸通过，不过 Foo::add 这个函数的参数列表确实是 (void*, int, int) 的，怎么把这个函数的指针弄出来是个问题

对引用取地址

Sat, 29 Mar 2014 18:00:48 +0800

今天突然想到，如果我们对一个引用取地址，那么会怎么样呢，例如这样

#include <stdio.h>

class CNumber {
public:
	int n;
};

void printByPointer(CNumber* pNumber) {
	printf("%d\n", pNumber->n);
}

void printByRef(CNumber& oNumber) {
	printf("%d\n", oNumber.n);
}

void passPointer(CNumber& oNumber) {
	printByPointer(&oNumber);
}

int main() {
	CNumber oNumber;
	oNumber.n = 5;
	printByPointer(&oNumber);
	printByRef(oNumber);
	passPointer(oNumber);
	return 0;
}

显然前面两个都可以正常运行，那么第三个呢，实测下来，也是可以的，也就是说，对一个引用取地址，可以得到正确的地址

tr1 memory 中的智能指针

Tue, 11 Mar 2014 09:34:04 +0800

tr1/memory 中带了一个 shared_ptr 的智能指针，也有配套的 weak_ptr，但是没有 scoped_ptr，不过起码可以不用等到 c++11 的编译器了

#include <tr1/memory>
#include <stdio.h>

class CTest {
    public:
        CTest() {
            printf("CTest\n");
        }
        ~CTest() {
            printf("~CTest\n");
        }
};

std::tr1::shared_ptr<CTest> GetSharedTest() {
    printf("in get\n");
    std::tr1::shared_ptr<CTest> pTest(new CTest());
    printf("leaving get\n");
    return pTest;
}


int main() {
    std::tr1::shared_ptr<CTest> pTest = GetSharedTest();
    return 0;
}

输出

in get
CTest
leaving get
~CTest

-—————————————

2014-3-17 11:11:26 update 常说要 RAII，来看看文件操作如何 RAII

#include <stdio.h>
#include <string>
#include <assert.h>
#include <tr1/memory>

class CFile {
public:
    FILE* fp;
    CFile(const char* pPathToFile, const char* pMod) {
        printf("opening %s with mod %s\n", pPathToFile, pMod);
        fp = fopen(pPathToFile, pMod);
    }
    ~CFile() {
        if (fp) {
            printf("closing file\n");
            fclose(fp);
        }
    }
private:
    CFile(CFile const &);
    CFile& operator=(CFile const &);
};
typedef std::tr1::shared_ptr<CFile> FileSharedPtr;

int main() {
    FileSharedPtr pFile(new CFile("test.txt", "w"));
    assert(pFile->fp != NULL);
    std::string strGreeting("hello");
    fwrite(strGreeting.c_str(), strGreeting.length(), 1, pFile->fp);
    return 0;
}

函数返回对象时的问题

Fri, 24 Jan 2014 18:58:20 +0800

来看这个代码

#include <iostream>
#include <string>
#include <map>

std::map<std::string, std::string> mapHttpRequest;

std::string GetString(std::string strKey)
{
    std::map<std::string, std::string>::iterator it = mapHttpRequest.find(strKey);
    if (it != mapHttpRequest.end())
    {
        return it->second;
    }    
    return "";
}

int SplitString()
{
    std::string strUrlParamValue = GetString("l");
    std::cout<<"before: "<<strUrlParamValue<<std::endl;
    char *pInOuter;
    char* p = strtok(const_cast<char*>(strUrlParamValue.c_str()), "|_");
    while (p)
    {
        std::cout<<"-> "<<p<<std::endl;
        p = strtok(NULL, "|_");
    }
    std::cout<<"after: "<<strUrlParamValue<<std::endl;
    return 0;
}

int main()
{
    mapHttpRequest["l"] = "4001|4002";
    SplitString();
    SplitString();
    return 0;
}

一般理解，连续调用两次 split string 函数，输出应该是完全一致的吧，嗯，来看结果

before: 4001|4002
-> 4001
-> 4002
after: 40014002
before: 40014002
-> 4001
after: 40014002

环境是 linux 2.6.16 64bit，gcc 的版本是 4.1.2

不过，在 vs 2005 下跑这个代码，得到的输出确实这样的

before: 4001|4002
-> 4001
-> 4002
after: 4001 4002
before: 4001|4002
-> 4001
-> 4002
after: 4001 4002

嗯，这个跟想象中的差不多吧

把细节打出来看看呗

#include <iostream>
#include <string>
#include <map>

std::map<std::string, std::string> mapHttpRequest;

std::string GetString(std::string strKey)
{
    std::map<std::string, std::string>::iterator it = mapHttpRequest.find(strKey);
    if (it != mapHttpRequest.end())
    {
        std::cout<<"map value addr: "<<(void*)it->second.c_str()<<std::endl;
        return it->second;
    }    
    return "";
}

int SplitString()
{
    std::string strUrlParamValue = GetString("l");
    std::cout<<"get string func return addr: "<<(void*)strUrlParamValue.c_str()<<std::endl;
    std::cout<<"before: "<<strUrlParamValue<<std::endl;
    char *pInOuter;
    char* p = strtok(const_cast<char*>(strUrlParamValue.c_str()), "|_");
    while (p)
    {
        std::cout<<(void*)p<<" -> "<<p<<std::endl;
        p = strtok(NULL, "|_");
    }
    std::cout<<"after: "<<strUrlParamValue<<std::endl;
    return 0;
}

int main()
{
    mapHttpRequest["l"] = "4001|4002";
    SplitString();
    SplitString();
    return 0;
}

先看 linux 下的结果

map value addr: 0x504098
get string func return addr: 0x504098
before: 4001|4002
0x504098 -> 4001
0x50409d -> 4002
after: 40014002
map value addr: 0x504098
get string func return addr: 0x504098
before: 40014002
0x504098 -> 4001
after: 40014002

再看 vs 2005 的执行结果

map value addr: 005D345C
get string func return addr: 0018FDF8
before: 4001|4002
0018FDF8 -> 4001
0018FDFD -> 4002
after: 4001 4002
map value addr: 005D345C
get string func return addr: 0018FDF8
before: 4001|4002
0018FDF8 -> 4001
0018FDFD -> 4002
after: 4001 4002

其中的原因，有可能是编译器的返回值优化，也有可能是 stl 的各自实现不同，现在过年了，没心情细究啊。。

pthread_self 和 gettid 的性能区别

Wed, 18 Dec 2013 18:00:51 +0800

打日志的时候，我们希望把线程 id 打印出来，线程 id 有两个方法可以获取，gettid 和 pthread_self，前者是一个 Linux 的系统调用，后者是一个可移植的库函数，可移植性倒还好，因为也不怎么考虑跨平台，另外一个区别，就是他们的返回值不一样，这个可以看到这里，http://stackoverflow.com/questions/6372102/what-is-the-difference-between-pthread-self-and-gettid-which-one-should-i-u，有一个讨论，摘录如下：

They are not the same. Here are some bits I collected from TLPI (I couldn’t find a large-enough block that completely describes this). If you’re in a hurry you probably want just the last part.

gettid

Linux 2.4 introduced a new system call, gettid(), to allow a thread to obtain its own thread ID.

Each thread within a thread group is distinguished by a unique thread identifier. A thread ID is represented using the same data type that is used for a process ID, pid_t. Thread IDs are unique system-wide, and the kernel guarantees that no thread ID will be the same as any process ID on the system, except when a thread is the thread group leader for a process.

pthread_self

Each thread within a process is uniquely identified by a thread ID. A thread can obtain its own ID using pthread_self().

The pthread_equal() function is needed to compare thread ids because the pthread_t data type must be treated as opaque data.

In the Linux threading implementations, thread IDs are unique across processes. However, this is not necessarily the case on other implementations, and SUSv3 explicitly notes that an application can’t portably use a thread ID to identify a thread in another process.

gettid vs pthread_self

POSIX thread IDs are not the same as the thread IDs returned by the Linux-specific gettid() system call. POSIX thread IDs are assigned and maintained by the threading implementation. The thread ID returned by gettid() is a number (similar to a process ID) that is assigned by the kernel.

I would go with pthread_setaffinity_np but be aware that the manual says:

These functions are implemented on top of the sched_setaffinity(2)

简单的说，就是一个是给出系统范围内的唯一 id，另外一个是给出进程范围内的唯一值，这个也不太重要吧，另外这里，给出了一些源码的跟踪，http://zhwen.org/xlog/?p=622，接下来就是考虑性能问题了，首先来看 pthread_self

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <iostream>

#define gettid() syscall(__NR_gettid)  

int main() {
    //pid_t tid;
    pthread_t tid;
    int iTestCase = 10000000;
    while (iTestCase--) {
        //tid = gettid();
        tid = pthread_self();
        tid++;
    }
    std::cout<<tid<<std::endl;
    return 0;
}

那个自增，是为了防止编译器优化，输出如下

$ time ./a.out 
47071132892337

real	0m0.036s
user	0m0.036s
sys	0m0.000s

话说这个 id 还真是长啊。。然后来看看 gettid 的情况

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <iostream>

#define gettid() syscall(__NR_gettid)  

int main() {
    pid_t tid;
    //pthread_t tid;
    int iTestCase = 10000000;
    while (iTestCase--) {
        tid = gettid();
        //tid = pthread_self();
        tid++;
    }
    std::cout<<tid<<std::endl;
    return 0;
}

来看耗时

$ time ./a.out 
3904

real	0m0.543s
user	0m0.236s
sys	0m0.308s

居然慢了几乎 18 倍，这个差距就太大了

基于队列的 UDP 多线程收发 demo

Tue, 10 Dec 2013 15:46:01 +0800

来看这个代码

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        if (stInQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stInQueueMutex);
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        if (stOutQueue.empty())
        {
            continue;
        }
        pthread_mutex_lock(&stOutQueueMutex);
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

用 python 写个客户端测试一下

#!/usr/bin/env python

import socket

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    data = raw_input('> ')
    if not data:
        break
    udpCliSock.sendto(data, ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print ADDR, data

udpCliSock.close()

跑起来似乎没有问题

[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0069] udp recv thread start
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0085] udp send thread start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1107310912 start
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0044] udp process thread 1098918208 start
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 1
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 1
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 1
[DEBUG:       UdpRecvThread@        EpollUdp.cpp,0076] recv 1 bytes from ip 10.31.18.40 port 62272 message 2
[DEBUG:    UdpProcessThread@        EpollUdp.cpp,0055] thread 1107310912 processing the request 2
[DEBUG:       UdpSendThread@        EpollUdp.cpp,0097] send 1 bytes to ip 10.31.18.40 port 62272 message 2

但是多发几次，就 core 了，这是为什么呢，gdb 调试发现 core 在 memcpy 上面，这个也不太能理解，不过，把代码尝试的改成这样就可以了

#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <string.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <queue>
#include <pthread.h>

#define _PRINTF_(format, ...) printf("[%s:%20s@%20s,%04d] " format "\n", "DEBUG",__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__ );

static const int iBufferSize = 2048;
int iUdpServerFd;
static const unsigned short uiUdpServerPort = 6000;
static const int iUdpProcessThreadNumber = 2;

struct InQueueEvent
{
    struct sockaddr_in stClientAddr;
    socklen_t stClienAddrLen;
    char szRecvBuffer[iBufferSize];
    int iRecvLen;
};

struct OutQueueEvent
{
    struct sockaddr_in stDestAddr;
    socklen_t stDestAddrLen;
    char szSendBuffer[iBufferSize];
    int iSendContentLen;
};

std::queue<struct InQueueEvent> stInQueue;
pthread_mutex_t stInQueueMutex;
std::queue<struct OutQueueEvent> stOutQueue;
pthread_mutex_t stOutQueueMutex;

void* UdpProcessThread(void*)
{
    _PRINTF_("udp process thread %ld start", pthread_self());
    while (1)
    {
        pthread_mutex_lock(&stInQueueMutex);
        if (stInQueue.empty())
        {
            pthread_mutex_unlock(&stInQueueMutex);
            continue;
        }
        struct InQueueEvent stInQueueEvent = stInQueue.front();
        stInQueue.pop();
        pthread_mutex_unlock(&stInQueueMutex);
        _PRINTF_("thread %ld processing the request %s", pthread_self(), stInQueueEvent.szRecvBuffer);
        struct OutQueueEvent stOutQueueEvent;
        memset(&stOutQueueEvent, 0, sizeof(stOutQueueEvent));
        stOutQueueEvent.stDestAddr = stInQueueEvent.stClientAddr;
        stOutQueueEvent.stDestAddrLen = stInQueueEvent.stClienAddrLen;
        memcpy(stOutQueueEvent.szSendBuffer, stInQueueEvent.szRecvBuffer, stInQueueEvent.iRecvLen);
        stOutQueueEvent.iSendContentLen = stInQueueEvent.iRecvLen;
        pthread_mutex_lock(&stOutQueueMutex);
        stOutQueue.push(stOutQueueEvent);
        pthread_mutex_unlock(&stOutQueueMutex);        
    }
}

void* UdpRecvThread(void*)
{
    _PRINTF_("udp recv thread start");
    while(1)
    {
        struct InQueueEvent stInQueueEvent;
        memset(&stInQueueEvent, 0, sizeof(stInQueueEvent));
        stInQueueEvent.stClienAddrLen = sizeof(stInQueueEvent.stClientAddr);
        stInQueueEvent.iRecvLen = recvfrom(iUdpServerFd, &(stInQueueEvent.szRecvBuffer), sizeof(stInQueueEvent.szRecvBuffer), 0, (struct sockaddr*)&(stInQueueEvent.stClientAddr), &(stInQueueEvent.stClienAddrLen));
        _PRINTF_("recv %d bytes from ip %s port %d message %s", stInQueueEvent.iRecvLen, inet_ntoa(stInQueueEvent.stClientAddr.sin_addr), ntohs(stInQueueEvent.stClientAddr.sin_port), stInQueueEvent.szRecvBuffer);
        pthread_mutex_lock(&stInQueueMutex);
        stInQueue.push(stInQueueEvent);
        pthread_mutex_unlock(&stInQueueMutex);
    }
}

void* UdpSendThread(void*)
{
    _PRINTF_("udp send thread start");
    while(1)
    {
        pthread_mutex_lock(&stOutQueueMutex);
        if (stOutQueue.empty())
        {
            pthread_mutex_unlock(&stOutQueueMutex);
            continue;
        }
        struct OutQueueEvent stOutQueueEvent = stOutQueue.front();
        stOutQueue.pop();
        pthread_mutex_unlock(&stOutQueueMutex);
        int iSendLen = sendto(iUdpServerFd, &(stOutQueueEvent.szSendBuffer), stOutQueueEvent.iSendContentLen, 0, (struct sockaddr*)&(stOutQueueEvent.stDestAddr), stOutQueueEvent.stDestAddrLen);
        _PRINTF_("send %d bytes to ip %s port %d message %s", iSendLen, inet_ntoa(stOutQueueEvent.stDestAddr.sin_addr), ntohs(stOutQueueEvent.stDestAddr.sin_port), stOutQueueEvent.szSendBuffer);
    }
}

int CreateUdpServer(unsigned short uiUdpServerPort)
{
    int iListenFd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(iListenFd > 0);
    struct sockaddr_in stListenAddr;
    memset(&stListenAddr, 0, sizeof(stListenAddr));
    stListenAddr.sin_family = AF_INET;
    stListenAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    stListenAddr.sin_port = htons(uiUdpServerPort);
    int iReuseFlag = 1;
    assert(setsockopt(iListenFd, SOL_SOCKET, SO_REUSEADDR, &iReuseFlag, sizeof(int)) == 0);
    assert(bind(iListenFd, (struct sockaddr*)&stListenAddr, sizeof(stListenAddr)) == 0);  
    return iListenFd;
}

int main()
{
    pthread_mutex_init(&stInQueueMutex, NULL);
    pthread_mutex_init(&stOutQueueMutex, NULL);
    iUdpServerFd = CreateUdpServer(uiUdpServerPort);
    pthread_t tid;
    assert(pthread_create(&tid, NULL, UdpRecvThread, NULL) == 0);
    assert(pthread_create(&tid, NULL, UdpSendThread, NULL) == 0);
    for (int i = 0; i < iUdpProcessThreadNumber; i++)
    {
        assert(pthread_create(&tid, NULL, UdpProcessThread, NULL) == 0);
    }    
    while (1)
    {
        sleep(10);
    }
    return 0;
}

注意高亮的部分，在检查队列是否为空的时候，也要包含在锁的区域里面，这样就可以了

-———————————————

2013-12-10 16:37:06 update 使用这个脚本，可以多线程压测服务

#!/usr/bin/env python

import socket
import random
import threading

HOST = 'xx.xx.xx.xx'
PORT = 6000
BUFSIZ = 1024
ADDR = (HOST, PORT)

class UdpTestThread(threading.Thread):
    def run(self):
        udpCliSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        for i in range(1000):
            data = str(random.random())
            udpCliSock.sendto(data, ADDR)
            data = udpCliSock.recvfrom(BUFSIZ)
            #print data
        udpCliSock.close()

for i in range(50):
    UdpTestThread().start()

-—————————

2013-12-10 17:21:05 update 发现上面的例子，压测结果很差，于是写了个极简的，作为比对

#include <sys/socket.h>
#include <arpa/inet.h>

int main() {
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(6000);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(fd, (struct sockaddr*)&addr, sizeof(addr));
    while (1) {
        char buffer[2048] = {0};
        struct sockaddr cli;
        socklen_t cli_len = sizeof(cli);
        int recv_len = recvfrom(fd, buffer, sizeof(buffer), 0, &cli, &cli_len);
        sendto(fd, buffer, recv_len, 0, &cli, cli_len);
    }
    return 0;
}

发现差不多，看来还要找原因

历史评论

wanax (2014-03-19 16:52:29):

这几天挖出来个GLib的，自带线程池和宏定义好了的锁，感觉再用C就顺手多了

ZRJ (2014-03-19 20:15:41):

其实用 libevent 基本就够了，不用造轮子

wanax (2014-03-20 09:49:23):

那玩意儿就是个轮子还附带各种数据结构与常用工具类

ZRJ (2014-03-20 19:58:08):

反正我现在是觉得能有稳定开源的就用呗

std unique 的实现

Thu, 07 Nov 2013 10:15:19 +0800

接触到 std 的 unique 这个函数，看了一下实现，自己也写了一下。在读默认的实现的时候发现代码真是的比较坑爹的，缩进啊，花括号啊，之类的，都是不按规范来的。

自己照着写了一个如下

#include <iostream>
#include <vector>

template<class It>
It myUnique(It itBegin, It itEnd) {
    for (It itBegin2; (itBegin2 = itBegin) != itEnd && ++itBegin != itEnd; ) {
        if (*itBegin2 == *itBegin) {
            for (; ++itBegin != itEnd; ) {
                if (*itBegin2 != *itBegin) {
                    *++itBegin2 = *itBegin;
                }
            }
            return ++itBegin2;
        }
    }
    return itEnd;
}

template<class It>
void iteratorPrint(It itBegin, It itEnd) {
    while (itBegin != itEnd) {
        printf("%d\n", *itBegin++);
    }
}

int main() {
    std::vector<int> numbers;
    numbers.push_back(3);
    numbers.push_back(4);
    numbers.push_back(4);
    numbers.push_back(5);
    numbers.push_back(5);
    numbers.push_back(6);
    numbers.push_back(6);
    iteratorPrint(numbers.begin(), numbers.end());
    printf("--------------------\n");
    myUnique(numbers.begin(), numbers.end());
    iteratorPrint(numbers.begin(), numbers.end());
    return 0;
}

输出如下

3
4
4
5
5
6
6
--------------------
3
4
5
6
5
6
6

注意到代码的 8 到 12 行，这个地方，他只是判等，一旦不等，就把后面的覆盖到前面来，那么，就需要要求，原来的序列里面，相同的元素是相邻的，另外，他只是覆盖，并不删除后面的，那么就要求，调用完这个函数之后，还要自己去把后面的也给删除了。

c++ 模版类调用不同函数

Sat, 21 Sep 2013 18:10:59 +0800

我们都知道，c++ 用模版，可以根据不同的对象类型，生成不同的实际函数，但是，如果我想根据不同的条件，在一个模版类里面，调用不同的函数呢，能不能这样写

#include <iostream>

using namespace std;

void PrintA(int a)
{
    cout<<a<<endl;
}

void PrintB(int b)
{
    cout<<b<<endl;
}

template<class F, class V>
void Call(V i)
{
    F(i);
}

int main()
{
    Call<PrintA, int>(1);
    Call<PrintB, int>(2);
    return 0;
}

遗憾的是，这东西连编译都编译不过，上网查了一下，也没发现有类似的讨论。。

历史评论

ZRJ (2013-09-21 18:12:20):

查了一下，发现这里有讨论，http://stackoverflow.com/questions/1174169/function-passed-as-template-argument

ZRJ (2013-09-22 13:00:45):

又想到其实这种情况，传个函数指针就能满足大部分要求了

kamuszhou (2013-09-25 13:46:10):

C++的作法是用“函数对象”，重写()操作符.

class PrintA { public: void operator()(int a) { cout<<a<<endl; } }; call函数的模板里再稍微改一下： F f; // 实例化函数对象 f(i);

大多数情况下，不用C++模块能把代码写得更干净.

ZRJ (2013-09-25 15:08:37):

嗯，还是用函数指针比较好，而且够用

Google perftools cpu profiler 对多进程的支持问题

Wed, 28 Aug 2013 11:05:48 +0800

折腾了好久，到目前还是没有让 gperftools cpu profiler 能在多进程环境下跑起来，问题如下：

main_cmd_argv.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <gperftools/profiler.h>

int loop(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            sum = i + j;
            if (sum %3 == 0) {
                sum /= 3;
            }
        }
    }
    return 0;
}

int main(int argc, char* argv[]) {

    printf("%s\n%s\n", getenv("CPUPROFILE"), getenv("CPUPROFILESIGNAL"));

    if (argc > 1 && strcmp(argv[1], "-s")==0) {
        // single process
        loop(100000);
        printf("stoped\n");
    } else if (argc > 1 && strcmp(argv[1], "-m")==0) {
        // multi process
        pid_t pid = fork();
        if (pid < 0) {
            printf("fork error\n");
            return -1;
        }
        if (pid == 0) {    
            loop(100000);
            printf("child stoped\n");
        } else if (pid > 0) {
            loop(10000);
            printf("father stoped\n");
            wait(NULL);
        }        
    }   

    return 0;
}

makefile

GPerfTools=/home/adenzhang/tools/gperftools

CCFLAGS=-fno-omit-frame-pointer -g -Wall

ALL_BINS=main_cmd_argv
all:$(ALL_BINS)

main_cmd_argv:main_cmd_argv.o
    g++ $(CCFLAGS) -o $@ $^ -L./ -L$(GPerfTools)/lib -Wl,-Bdynamic -lprofiler -lunwind

.cpp.o:
    g++ $(CCFLAGS) -c -I./ -I$(GPerfTools)/include -fPIC -o $@ $<
clean:
    rm -f $(ALL_BINS) *.o *.prof

运行过程

$ make
g++ -fno-omit-frame-pointer -g -Wall -c -I./ -I/home/adenzhang/tools/gperftools/include -fPIC -o main_cmd_argv.o main_cmd_argv.cpp
g++ -fno-omit-frame-pointer -g -Wall -o main_cmd_argv main_cmd_argv.o -L./ -L/home/adenzhang/tools/gperftools/lib -Wl,-Bdynamic -lprofiler -lunwind
$ env CPUPROFILE=main_cmd_argv.prof ./main_cmd_argv -s
젩n_cmd_argv.prof
(null)
stoped
PROFILE: interrupts/evictions/bytes = 6686/3564/228416
$ /home/adenzhang/tools/gperftools/bin/pprof --text ./main_cmd_argv ./main_cmd_argv.prof 
Using local file ./main_cmd_argv.
Using local file ./main_cmd_argv.prof.
Removing killpg from all stack traces.
Total: 6686 samples
    6686 100.0% 100.0%     6686 100.0% loop
       0   0.0% 100.0%     6686 100.0% __libc_start_main
       0   0.0% 100.0%     6686 100.0% _start
       0   0.0% 100.0%     6686 100.0% main
$ rm main_cmd_argv.prof 
$ env CPUPROFILE=main_cmd_argv.prof ./main_cmd_argv -m
젩n_cmd_argv.prof
(null)
father stoped
child stoped
PROFILE: interrupts/evictions/bytes = 0/0/64
PROFILE: interrupts/evictions/bytes = 68/36/2624
$ ls 
main_cmd_argv  main_cmd_argv.cpp  main_cmd_argv.o  main_cmd_argv.prof  Makefile
$ /home/adenzhang/tools/gperftools/bin/pprof --text ./main_cmd_argv ./main_cmd_argv.prof 
Using local file ./main_cmd_argv.
Using local file ./main_cmd_argv.prof.
$

先记下来吧，后面再想办法搞。

小广告贴的到处都是：http://stackoverflow.com/questions/18384760/gperftools-cpu-profiler-does-not-support-multi-process，https://groups.google.com/forum/#!topic/google-perftools/bmysZILR4ik，http://www.searchtb.com/2012/12/google-cpu-profiler.html，https://code.google.com/p/gperftools/issues/detail?id=569&can=1&q=multi%20process

另外有一个讲性能分析的 stackoverflow 问答，顺便记下来：http://stackoverflow.com/questions/375913/what-can-i-use-to-profile-c-code-in-linux/378024#378024

历史评论

ZRJ (2013-10-15 08:54:18):

最后的结果是这样的：

Aliaksey Kandratsenka alkondratenko@gmail.com 9月9日

发送至 google-perftoo. It looks like profiler sets up timer for main thread early and then fork (which creates new thread) does not inherit this. I’m not very familiar with that code but I find it weird.

Anyways I was able to enable profiling in child by calling ProfilerRegisterThread right after ProfilerStart. Which set up profiling signal for child and made it work.

动态链接库中的全局变量 | ZRJ (2015-03-27 11:35:46):

[…] 考虑到之前做函数耗时测试，和代码覆盖度测试的时候，遇到过由于进程关系复杂（又多进程又线程的）引起的问题，考虑是否由于这个原因引起的问题，于是写了这么一个测试 […]

strncpy 的用法

Tue, 27 Aug 2013 09:39:21 +0800

在官方的文档中，http://www.cplusplus.com/reference/cstring/strncpy/，例程的 strncpy 的用法是：

/* strncpy example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str1[]= "To be or not to be";
  char str2[40];
  char str3[40];

  /* copy to sized buffer (overflow safe): */
  strncpy ( str2, str1, sizeof(str2) );

  /* partial copy (only 5 chars): */
  strncpy ( str3, str2, 5 );
  str3[5] = '\0';   /* null character manually added */

  puts (str1);
  puts (str2);
  puts (str3);

  return 0;
}

注意到第 12 行，最后的参数是直接 sizeof，这样虽然可以防止溢出，但是其实还是 printf strlen 之类的不安全的，看看这个例子：

#include <stdio.h>
#include <string.h>

int main() {
    char str[3];
    memset(str, 0, sizeof(str));
    strncpy(str, "testtest", sizeof(str));
    printf("[%s][%d]\n", str, strlen(str));
    return 0;
}

看看输出：

$ ./a.out 
[tes][6]
$ ./a.out 
[tesx][6]
$ ./a.out 
[tesn][6]
$ ./a.out 
[tes][6]
$ ./a.out 
[tes][6]
$ ./a.out 
[tes*][6]
$ ./a.out 
[tes¡][6]
$ ./a.out 
[tesP][6]
$ ./a.out 
[tes][6]

可以看到，最后那个 char 是不确定的，而且 strlen 也出错，那么，稳妥的做法应该是 -1

#include <stdio.h>
#include <string.h>

int main() {
    char str[3];
    memset(str, 0, sizeof(str));
    strncpy(str, "testtest", sizeof(str)-1);
    printf("[%s][%d]\n", str, strlen(str));
    return 0;
}

$ ./a.out 
[te][2]
$ ./a.out 
[te][2]
$ ./a.out 
[te][2]
$ ./a.out 
[te][2]

这样才能有稳定的输出

历史评论

ZRJ (2013-09-29 21:13:02):

而另外，snprintf 则不需要 - 1

ZRJ (2014-01-27 17:17:24):

http://stackoverflow.com/questions/12275381/strncpy-vs-sprintf

使用代码块来缩小变量作用域

Wed, 24 Apr 2013 15:03:46 +0800

今天突发奇想，想到这么一个写法

#include <stdio.h>

int main() {
    char c = 'A';
    {
        int a = 1;
        printf("%d\n", a);
        printf("%c\n", c);
    }
    {
        int a = 2;
        printf("%d\n", a);
        printf("%c\n", c);
    }
    return 0;
}

编译一下，居然能够编译通过，跑一下，得到输出

1
A
2
A

这个东西有什么用呢，说实在，我也没有见过别人有这种写法，我自己也是脑子一抽筋想到的。

最明显的作用就是缩小变量的作用域，可以避免冲突，另外的话，这种用来区分不用作用的代码块，有助于一个长函数中对代码的阅读，不过，这要求两个代码块之间的变量几乎互相独立，真要这样的话，这个长函数干嘛不拆啊，囧。

历史评论

ZRJ (2013-10-11 19:47:05):

突然想到，这种写法，结合 RAII 形式的互斥锁，是可以达到规划临界区的目的的

Linux 多进程监听 socket

Thu, 11 Apr 2013 15:31:17 +0800

首先来看代码

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1 ) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }
    if (listen(sockfd, 20) == -1) {
        perror("listen");
        return -1;
    }
    for (int i = 0; i < 2; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
        } else if (pid == 0) {
            // child process
            while (1) {
                struct sockaddr_in cli_addr;
                memset(&cli_addr, 0, sizeof(cli_addr));
                socklen_t cli_addr_len = 0;
                int connfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_addr_len);
                if (connfd == -1) {
                    perror("accept");
                    return -1;
                }
                char *cli_addr_str = inet_ntoa(cli_addr.sin_addr);
                int cli_addr_port = ntohs(cli_addr.sin_port);
                printf("pid: %d, cli addr: %s:%d\n", getpid(), cli_addr_str, cli_addr_port);
                char buff[4096] = {0};
                if (recv(connfd, buff, sizeof(buff), 0) == -1) {
                    perror("recv");
                    return -1;
                }
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\nhello";
                if (send(connfd, html_resp, strlen(html_resp), 0) == -1) {
                    perror("send");
                    return -1;
                }
                close(connfd);
            }        
        } else if (pid > 0) {
            // parent process
            printf("forked pid: %d\n", pid);
        }
    }
    while (1) {
        pid_t end_pid = wait(NULL);
        if (end_pid == -1) {
            perror("wait");
            return -1;
        }
        printf("child process %d end\n", end_pid);
    }
    close(sockfd);
    return 0;
}

编译一下

g++ -Wall -g main.cpp -o addrreuse.exe

多次模拟请求

wget http://localhost:8080/123

服务端的输出如下：

forked pid: 23278
forked pid: 23279
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0

事实证明，是可以多个进程来 accept 一个 sockfd 的，（好吧，高手当我在说废话就行了），然后注意到有一个东西叫惊群效应，http://blog.csdn.net/chenxinl/article/details/6376895

惊群效应：指一个fd的事件被触发后，等候这个fd的所有线程/进程都被唤醒。低版本的linux内核在accept这边有所谓的“惊群效应”，是指一个链接过来，会把堵塞在accept上的所有子进程都唤醒；但是只有一个子进程都读取到链接，其他子进程唤醒后发现没有数据，继续睡觉去了；这样就产生了大量的进程切换开销。但目前的内核版本已经修复了这个问题，一个链接过来，内核只会唤醒一个子进程出来accept，这样就不用担心惊群效应了。但是对于其他类型的fd，惊群效应还是存在的，而且是必须的；比如多个进程wait在一个pipe的读事件上，有数据过来后，多个进程都会被唤醒，因为内核也不知道这些数据就给一个进程读的，还是每个进程都读一点，这个逻辑是应用层控制的；而accept也相当于一个读事件，但内核确认一个进程接受一个链接就可以了。同理，如果多个子进程把同一个listen的fd添加到各自的epoll_wait中，有链接过来会导致所有的子进程唤醒，这也会导致惊群效应；但这个是应用层面需要解决的问题。关于httpserver惊群效应和如何处理：http://bbs3.chinaunix.net/viewthread.php?action=printable&tid=1676724

但是另外看到这里，http://www.iteye.com/topic/561424

在2.6内核下，内核只会wakeup一个进程。就是说，2.6的内核下面，不会出现惊群的现象。

Linux TCP UDP 混合

Mon, 08 Apr 2013 16:07:14 +0800

基本的思路是这样的：在服务器端，有两个机器，一个对外开启 TCP 监听，然后把监听到的请求内容送到后面的另外一台，或者多台轮询机器上，内网之间使用 UDP，然后等待业务逻辑机器处理完成，这个地方可以做成异步的，然后再返回到用户。

即是这样： client <-TCP-> server_front <-UDP-> server_back

下面来看代码，首先是 server_front 的 demo

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>

#include "struct.h"

int main() {
    int tcpfd = socket(AF_INET, SOCK_STREAM, 0);
    if (tcpfd == -1) {
        perror("tcpfd socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(38080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(tcpfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("tcpfd bind");
        return -1;
    }
    if (listen(tcpfd, 10) == -1) {
        perror("tcpfd listen");
        return -1;
    }
    
    // udp
    int udpfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpfd == -1) {
        perror("udpfd socket");
        return -1;
    }
    struct sockaddr_in udp_serv_addr;
    memset(&udp_serv_addr, 0, sizeof(udp_serv_addr));
    udp_serv_addr.sin_family = AF_INET;
    udp_serv_addr.sin_port = htons(8080);
    if (inet_pton(AF_INET, "10.1.164.18", &udp_serv_addr.sin_addr) <= 0) {
        perror("udpfd inet pton");
        return -1;
    }
    
    while (1) {
        int tcp_conn_fd = accept(tcpfd, NULL, NULL);
        if (tcp_conn_fd == -1) {
            perror("tcpfd accept");
            return -1;
        }
        char buff[2048];
        memset(buff, 0, sizeof(buff));
        int recvn = recv(tcp_conn_fd, buff, sizeof(buff), 0);
        if (recvn == -1) {
            perror("tcpfd recv");
            return -1;
        }
        printf("recv: [%s]\n", buff);
        //char html_resp[] = "HTTP/1.1 200 OK\r\n\r\ntcp udp mix";
        UDP_MSG udp_msg;
        memset(&udp_msg, 0, sizeof(udp_msg));
        strcpy(udp_msg.str1, "HTTP/1.1 200 OK\r\n\r\n");
        strcpy(udp_msg.str2, "send to udp for cat");
        if (sendto(udpfd, &udp_msg, sizeof(udp_msg), 0, (struct sockaddr*)&udp_serv_addr, sizeof(udp_serv_addr)) == -1) {
            perror("udp send to");
            return -1;
        }
        if (recvfrom(udpfd, &udp_msg, sizeof(udp_msg), 0, NULL, NULL) == -1) {
            perror("udp recv from");
            return -1;
        }
        if (send(tcp_conn_fd, udp_msg.cat, strlen(udp_msg.cat), 0) == -1) {
            perror("tcp send");
            return -1;
        }
        close(tcp_conn_fd);
    }
    close(tcpfd);
    return 0;
}

然后是内部的报文格式 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是后端的业务逻辑服务器

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

编译一下，就可以测试了

$ wget http://localhost:38080/123 && nl 123
--16:05:03--  http://localhost:38080/123
           => `123.2'
Resolving localhost... 127.0.0.1
Connecting to localhost|127.0.0.1|:38080... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified

    [<=> ] 19            --.--K/s             

16:05:03 (3.62 MB/s) - `123.2' saved [19]

     1	send to udp for cat

期间，server_front 的输出应该是这样的

recv: [GET /123 HTTP/1.0
User-Agent: Wget/1.10.2
Accept: */*
Host: localhost:38080
Connection: Keep-Alive

]

后台业务逻辑服务器的输出应该是这样的

msg.add1 is: 0
msg.add2 is: 0
msg.sum is: 0
msg.str1 is: HTTP/1.1 200 OK


msg.str2 is: send to udp for cat
msg.cat is: HTTP/1.1 200 OK

send to udp for cat

Linux UDP 收发实例

Sun, 07 Apr 2013 18:33:05 +0800

首先我们需要一个 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是服务端的

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

然后是客户端的

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (sendto(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
            perror("write");
            return -1;
        }
        socklen_t serv_addr_len = sizeof(serv_addr);
        if (recvfrom(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, &serv_addr_len) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

客户端另外一种，像这样的写法也行。。

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("connect");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (write(sockfd, &msg, sizeof(msg)) == -1) {
            perror("write");
            return -1;
        }
        if (read(sockfd, &msg, sizeof(msg)) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

然后编译

g++ -Wall -g serv.cpp -o serv.exe
g++ -Wall -g cli.cpp -o cli.exe

就可以运行了

历史评论

ZRJ (2013-04-07 18:33:34):

补充来源：http://www.chinaitpower.com/A200508/2005-08-02/182672.html

共享内存的读写

Tue, 26 Mar 2013 17:32:22 +0800

首先我们需要一个 shm_com.h

#ifndef _SHM_COM_H_
#define _SHM_COM_H_

#define TEXT_SZ 2048

struct shared_use_st {
    int written_by_you;
    char some_text[TEXT_SZ];
};

#endif /* _SHM_COM_H  */

然后是 shm1.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    int shmid;

    srand((unsigned int)getpid());
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;
    shared_stuff->written_by_you = 0;
    while (running) {
        if (shared_stuff->written_by_you) {
            printf("You wrote: %s", shared_stuff->some_text);
            sleep(rand() % 4);
            shared_stuff->written_by_you = 0;
            if (strncmp(shared_stuff->some_text, "end", 3) == 0) {
                running = 0;
            }
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    if (shmctl(shmid, IPC_RMID, 0) == -1) {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
   
    return 0;
}

然后是 shm2.cpp

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    char buffer[TEXT_SZ];
    
    int shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;

    while (running) {
        while (shared_stuff->written_by_you == 1) {
            sleep(1);
            printf("waiting for client...\n");
        }
        printf("Enter some text: ");
        fgets(buffer, TEXT_SZ, stdin);
        strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
        shared_stuff->written_by_you = 1;

        if (strncmp(buffer, "end", 3) == 0) {
            running = 0;
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    
    return 0;
}

编译一下

g++ -g -Wall shm1.cpp -o shm1.exe
g++ -g -Wall shm2.cpp -o shm2.exe

就可以运行了

-——————————————————————-

2013-03-28 20:04:11 update：注意 shmdt 和 shmctl 两种方式结束共享内存是不同的，shmdt 只是当前进程脱离共享内存，不对内存造成其他影响，而 shmctl 方式是删除这片内存，那样的话，其他的进程就再也无法 attach 这片内存了（已经 attach 上的可以继续）用，但是系统会把这片内存标记为 dest

[转]一份高质量的 Epoll 服务端代码

Mon, 25 Mar 2013 14:10:37 +0800

来自https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/epoll-example.c，由http://www.oschina.net/translate/how-to-use-epoll-a-complete-example-in-c?from=20130303提及

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXEVENTS 64

static int
make_socket_non_blocking (int sfd)
{
  int flags, s;

  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    {
      perror ("fcntl");
      return -1;
    }

  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    {
      perror ("fcntl");
      return -1;
    }

  return 0;
}

static int
create_and_bind (char *port)
{
  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;

  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */

  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    {
      fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
      return -1;
    }

  for (rp = result; rp != NULL; rp = rp->ai_next)
    {
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        {
          /* We managed to bind successfully! */
          break;
        }

      close (sfd);
    }

  if (rp == NULL)
    {
      fprintf (stderr, "Could not bind\n");
      return -1;
    }

  freeaddrinfo (result);

  return sfd;
}

int
main (int argc, char *argv[])
{
  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;

  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);
      exit (EXIT_FAILURE);
    }

  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();

  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();

  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort ();
    }

  efd = epoll_create1 (0);
  if (efd == -1)
    {
      perror ("epoll_create");
      abort ();
    }

  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort ();
    }

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    {
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
	{
	  if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
	    {
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
	      fprintf (stderr, "epoll error\n");
	      close (events[i].data.fd);
	      continue;
	    }

	  else if (sfd == events[i].data.fd)
	    {
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }

                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();

                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort ();
                    }
                }
              continue;
            }
          else
            {
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;

              while (1)
                {
                  ssize_t count;
                  char buf[512];

                  count = read (events[i].data.fd, buf, sizeof buf);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }

                  /* Write the buffer to standard output */
                  s = write (1, buf, count);
                  if (s == -1)
                    {
                      perror ("write");
                      abort ();
                    }
                }

              if (done)
                {
                  printf ("Closed connection on descriptor %d\n",
                          events[i].data.fd);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
                  close (events[i].data.fd);
                }
            }
        }
    }

  free (events);

  close (sfd);

  return EXIT_SUCCESS;
}

不同服务器端模型在并发请求下的表现差异

Mon, 25 Mar 2013 11:22:04 +0800

一般来说，服务器的模型有下面几种：

单进程单线程
多进程（一个请求对应一个进程，Apache 之类貌似就是这个）
多线程（一个请求对应一个线程，这个挺少见到的）
select / poll
epoll

它们的差别可以看这个，http://www.cnblogs.com/sharra/archive/2010/12/30/1921287.html

因为需要了解底层设备访问的原理，所以惯用高层应用语言的我，需要了解一下Linux的设备访问机制，尤其是处理一组非阻塞IO的原理方法，标准的术语好像是叫多路复用。以下文章部分句子有引用之处，恕没有一一指出出处。对于接触过Linux内核或设备驱动开发的读者，一定清楚poll和select系统调用，以及从2.5版本引入的epoll机制（epoll机制包含三个系统调用）。网上关于它们的文章，有说用法的，甚为详细，更有分析源代码的，又比较深入，且枝节颇多。经过几篇文章的阅读，我把觉得比较核心的东西写下来吧。我的用意是尽可能以简单的概念，比对他们三者的异同。几经查找我才确定下来，poll和select应该被归类为这样的系统调用，它们可以阻塞地同时探测一组支持非阻塞的IO设备，是否有事件发生（如可读，可写，有高优先级的错误输出，出现错误等等），直至某一个设备触发了事件或者超过了指定的等待时间——也就是它们的职责不是做IO，而是帮助调用者寻找当前就绪的设备。同类型的产品是Windows的IOCP，它也是处理多路复用，只是把IO和探测封装在了一起了。准备的知识有两点：1、fd；2、op->poll。在Linux里面，设备都被抽象为文件，一系列的设备文件就有自己独立的虚拟文件系统，所以，设备在系统调用参数中的表示就是file description。fd其实就是一个整数（特别地，标准输入，输出，错误输出分别对应的fd是0，1，2）。与内核打交道的时候，传递整数的fd可以在自己的文件系统中作进一步的检查是否合法，如果只是返回指针就不能这样操作了，毕竟指针是无差别无意义的。通过fd访问file，通过file可以访问其fileOperator，这里面我们要关心的一个fileOp就是poll。因为系统调用poll和select，就是依靠这个文件操作poll实现的。poll文件操作有两个参数，一个是文件本身，一个可以看做是当设备尚未就绪时调用的回调函数，这个函数是把设备自己特有的等待队列传给内核，让内核把当前的进程挂载到其中（因为当设备就绪时，设备就应该去唤醒在自己特有等待队列中的所有节点，这样当前进程就获取了完成的信号了）。poll文件操作返回的必须是一组标准的掩码，其中的各个位指示当前的不同的就绪状态（全0为没有任何事件触发）。再谈谈早期多路复用的版本poll和select。本质而言，poll和select的共同点就是，对全部指定设备做一次poll，当然这往往都是还没有就绪的，那就会通过回调函数把当前进程注册到设备的等待队列，如果所有设备返回的掩码都没有显示任何的事件触发，就去掉回调函数的函数指针，进入有限时的睡眠状态，再恢复和不断做poll，再作有限时的睡眠，直到其中一个设备有事件触发为止。只要有事件触发，系统调用返回，回到用户态，用户就可以对相关的fd作进一步的读或者写操作了。当然，这个时候还不是所有的设备都就绪的喔，那就得不断地poll或者select了，而做一次这样的系统调用都得轮询所有的设备，次数是设备数*（睡眠次数-1），也就是时间复杂度是O（n），还得做几次O（n）呢。可见，对于现在普遍的服务器程序，需要同时并发监听数千个连接，并且连接需要重复使用的情况，poll和select就存在这样的性能瓶颈。另外，数千个设备fd在每次调用时，都需要将其从用户空间复制到内核空间，这里的开销不可忽略。 poll和select放在一起，是因为其机制一致，而参数和数据结构就略有不同。select一次性传入三组作用于不同信道的设备fd，分别是输入，输出和错误异常。各组的fd期待各组所特有的，由代码指定的一组事件，如输入信道期待输入就绪，输入挂起和错误等事件。然后，select就挑选调用者关心的fd做poll文件操作，检测返回的掩码，看看是否有fd所属信道感兴趣的事件，比如看看这个属于输出信道的fd有没有输出就绪等一系列的事件发生，一样地，如果有一个fd发生感兴趣事件就返回调用了。select，为了同时处理三组使用不同的事件判断规则的fd，采用了位图的方式表示，一组一个位图，位长度是当中最大的fd值，上限是1024，三组就是3072，而且这还只是传入的位图，还有一样大小的传出的位图。当fd数越来越多时，所需的存储开销比较大。既然，一组fd处理起来比较粗放，那就各个fd自己准备好了。poll()系统调用是System V的多元I/O解决方案。它有三个参数，第一个是pollfd结构的数组指针，也就是指向一组fd及其相关信息的指针，因为这个结构包含的除了fd，还有期待的事件掩码和返回的事件掩码，实质上就是将select的中的fd，传入和传出参数归到一个结构之下，也不再把fd分为三组，也不再硬性规定fd感兴趣的事件，这由调用者自己设定。这样，不使用位图来组织数据，也就不需要位图的全部遍历了。按照一般队列地遍历，每个fd做poll文件操作，检查返回的掩码是否有期待的事件，以及做是否有挂起和错误的必要性检查，如果有事件触发，就可以返回调用了。回到poll和select的共同点，面对高并发多连接的应用情境，它们显现出原来没有考虑到的不足，虽然poll比起select又有所改进了。除了上述的关于每次调用都需要做一次从用户空间到内核空间的拷贝，还有这样的问题，就是当处于这样的应用情境时，poll和select会不得不多次操作，并且每次操作都很有可能需要多次进入睡眠状态，也就是多次全部轮询fd，我们应该怎么处理一些会出现重复而无意义的操作。这些重复而无意义的操作有：1、从用户到内核空间拷贝，既然长期监视这几个fd，甚至连期待的事件也不会改变，那拷贝无疑就是重复而无意义的，我们可以让内核长期保存所有需要监视的fd甚至期待事件，或者可以再需要时对部分期待事件进行修改；2、将当前线程轮流加入到每个fd对应设备的等待队列，这样做无非是哪一个设备就绪时能够通知进程退出调用，聪明的开发者想到，那就找个“代理”的回调函数，代替当前进程加入fd的等待队列好了（这也是我后来才总结出来，Linux的等待队列，实质上是回调函数队列吧，也可以使用宏来将当前进程“加入”等待队列，其实就是将唤醒当前进程的回调函数加入队列）。这样，像poll系统调用一样，做poll文件操作发现尚未就绪时，它就调用传入的一个回调函数，这是epoll指定的回调函数，它不再像以前的poll系统调用指定的回调函数那样，而是就将那个“代理”的回调函数加入设备的等待队列就好了，这个代理的回调函数就自己乖乖地等待设备就绪时将它唤醒，然后它就把这个设备fd放到一个指定的地方，同时唤醒可能在等待的进程，到这个指定的地方取fd就好了。我们把1和2结合起来就可以这样做了，只拷贝一次fd，一旦确定了fd就可以做poll文件操作，如果有事件当然好啦，马上就把fd放到指定的地方，而通常都是没有的，那就给这个fd的等待队列加一个回调函数，有事件就自动把fd放到指定的地方，当前进程不需要再一个个poll和睡眠等待了。 epoll机制就是这样改进的了。诚然，fd少的时候，当前进程一个个地等问题不大，可是现在和尚多了，方丈就不好管了。以前设备事件触发时，只负责唤醒当前进程就好了，而当前进程也只能傻傻地在poll里面等待或者循环，再来一次poll，也不知道这个由设备提供的poll性能如何，能不能检查出当前进程已经在等待了就立即返回，当然，我也不明白为什么做了一遍的poll之后，去掉回调函数指针了，还得再做，不是说好了会去唤醒进程的吗？现在就让事件触发回调函数多做一步。本来设备还没就绪就调用一个回调函数了，现在再在这个回调函数里面做一个注册另一个回调函数的操作，目的就是使得设备事件触发多走一步，不仅仅是唤醒当前进程，还要把自己的fd放到指定的地方。就像收本子的班长，以前得一个个学生地去问有没有本子，如果没有，它还得等待一段时间而后又继续问，现在好了，只走一次，如果没有本子，班长就告诉大家去那里交本子，当班长想起要取本子，就去那里看看或者等待一定时间后离开，有本子到了就叫醒他，然后取走。这个道理很简单，就是老师和班干们常说的，大家多做一点工作，我的工作就轻松很多了，尤其是需要管理的东西越来越多时。这种机制或者说模式，我想在Java的FutureTask里面应该也会用到的，一堆在线程池里面跑着的线程（当然这是任务，不是线程，接口是Callable，不是Runnable.run，是Callable.call，它是可以返回结果的），谁先做好就应该先处理呀，可是难道得一个个问吗？干脆就谁好了，谁就按照既定的操作暴露自己，这样FutureTask的get方法就可以马上知道当前最先完成的线程了，就可以取此线程返回结果了。 epoll由三个系统调用组成，分别是epoll_create，epoll_ctl和epoll_wait。epoll_create用于创建和初始化一些内部使用的数据结构；epoll_ctl用于添加，删除或者修改指定的fd及其期待的事件，epoll_wait就是用于等待任何先前指定的fd事件。关于epoll内部的数据结构，我就不能详细了解了。

下面就是分别实现一个 demo，然后用 ab 去压力测试，每回都是 10W 个请求，根据不同的并发量测试

单进程单线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        memset(&buff, 0, sizeof(buff));
        recv(connfd, buff, BUFFER_SIZE, 0);
        //printf("recv msg:\n%s\n", buff);
        char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
        send(connfd, resp, strlen(resp), 0);
        close(connfd);
    }
    
    close(listenfd);
    return 0;
}

一开始觉得这种简单粗暴的方式肯定不行，结果发现还别说，这东西的处理能力还是可以的，看测试结果

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.210 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13869.50 [#/sec] (mean)
Time per request:       0.072 [ms] (mean)
Time per request:       0.072 [ms] (mean, across all concurrent requests)
Transfer rate:          501.14 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       4
Waiting:        0    0   0.0      0       4
Total:          0    0   0.0      0       4

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      4 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.498 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    18186.97 [#/sec] (mean)
Time per request:       0.550 [ms] (mean)
Time per request:       0.055 [ms] (mean, across all concurrent requests)
Transfer rate:          657.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       6
Waiting:        0    0   0.1      0       6
Total:          0    1   0.1      1       6

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      6 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   5.816 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    17194.97 [#/sec] (mean)
Time per request:       5.816 [ms] (mean)
Time per request:       0.058 [ms] (mean, across all concurrent requests)
Transfer rate:          621.30 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   0.6      1      11
Processing:     1    5   0.8      5      15
Waiting:        0    2   0.6      2      12
Total:          2    6   0.6      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      6
  75%      6
  80%      6
  90%      6
  95%      6
  98%      7
  99%      7
 100%     15 (longest request)
linux:~/ab/httpd-2.4.3/support$

150 个并发的时候就不行了

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 150 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99956 requests completed
linux:~/ab/httpd-2.4.3/support$

接下来是多进程模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        signal(SIGCHLD, SIG_IGN);
        pid_t pid = fork();
        if (pid < 0) {
            printf("fork error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        } else if (pid == 0) {
            //printf("in child process\n");
            memset(&buff, 0, sizeof(buff));
            recv(connfd, buff, BUFFER_SIZE, 0);
            //printf("recv msg:\n%s\n", buff);
            char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
            send(connfd, resp, strlen(resp), 0);
            close(connfd);
            exit(0);
        } else if (pid > 0) {
            //printf("in parent process\n");
            close(connfd);
            continue;
        }
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   41.408 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2415.02 [#/sec] (mean)
Time per request:       0.414 [ms] (mean)
Time per request:       0.414 [ms] (mean, across all concurrent requests)
Transfer rate:          87.26 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     0    0   0.1      0       9
Waiting:        0    0   0.1      0       9
Total:          0    0   0.1      0       9

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      9 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   39.517 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2530.53 [#/sec] (mean)
Time per request:       3.952 [ms] (mean)
Time per request:       0.395 [ms] (mean, across all concurrent requests)
Transfer rate:          91.44 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       3
Processing:     0    4   0.4      4      64
Waiting:        0    4   0.4      4      64
Total:          1    4   0.4      4      64

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      4
  75%      4
  80%      4
  90%      4
  95%      4
  98%      4
  99%      4
 100%     64 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   39.980 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2501.28 [#/sec] (mean)
Time per request:       39.980 [ms] (mean)
Time per request:       0.400 [ms] (mean, across all concurrent requests)
Transfer rate:          90.38 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.3      0      17
Processing:     0   40   1.7     40     120
Waiting:        0   40   1.7     40     120
Total:          3   40   1.6     40     120

Percentage of the requests served within a certain time (ms)
  50%     40
  66%     40
  75%     41
  80%     41
  90%     41
  95%     42
  98%     43
  99%     44
 100%    120 (longest request)
linux:~/ab/httpd-2.4.3/support$

500 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 500 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      500
Time taken for tests:   63.222 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1581.72 [#/sec] (mean)
Time per request:       316.112 [ms] (mean)
Time per request:       0.632 [ms] (mean, across all concurrent requests)
Transfer rate:          57.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   38 520.0      0   21004
Processing:     3  208 2942.9     51   60202
Waiting:        0  208 2942.9     51   60202
Total:         24  247 3153.2     51   63206

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     53
  95%     54
  98%     55
  99%     61
 100%  63206 (longest request)
linux:~/ab/httpd-2.4.3/support$

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   71.625 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1396.16 [#/sec] (mean)
Time per request:       716.252 [ms] (mean)
Time per request:       0.716 [ms] (mean, across all concurrent requests)
Transfer rate:          50.45 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   68 628.8      0   21002
Processing:     1  442 4622.4     51   68587
Waiting:        0  442 4622.3     51   68587
Total:         17  510 4934.8     51   71588

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     54
  95%     55
  98%     59
  99%   4107
 100%  71588 (longest request)
linux:~/ab/httpd-2.4.3/support$

再来是多线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);
void* process_thread(void* sockfd);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

void* process_thread(void* sockfd) {
    //printf("thread created\n");
    int connfd = *((int *)sockfd);
    char buff[BUFFER_SIZE+1];
    memset(&buff, 0, sizeof(buff));
    recv(connfd, buff, BUFFER_SIZE, 0);
    //printf("recv msg:\n%s\n", buff);
    char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
    send(connfd, resp, strlen(resp), 0);
    close(connfd);
    //printf("thread about to exit\n");
    pthread_exit(NULL);
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        //printf("main thread about to create thread\n");
        pthread_t tid;
        pthread_attr_t opt;
        pthread_attr_init(&opt);
        pthread_attr_setdetachstate(&opt, PTHREAD_CREATE_DETACHED);
        if (pthread_create(&tid, &opt, process_thread, &connfd) != 0) {
            printf("error line: %d\t", __LINE__);
            perror(__FILE__);
            return -1;
        }
        pthread_attr_destroy(&opt);
        //printf("main thread finish creating thread\n");
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.629 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13108.37 [#/sec] (mean)
Time per request:       0.076 [ms] (mean)
Time per request:       0.076 [ms] (mean, across all concurrent requests)
Transfer rate:          473.64 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.1      0      24
Waiting:        0    0   0.1      0      23
Total:          0    0   0.1      0      24

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%     24 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99991 requests completed
linux:~/ab/httpd-2.4.3/support$

至于 select 和 poll 就没有写了，直接写 epoll 模型

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

using namespace std;

#define MAX_LINE 1024
#define OPEN_MAX 100
#define LISTENQ 1024
#define SERV_PORT 8080
#define INFTIM 1000
#define MAX_EVENTS 1024
#define EP_TIMEOUT 500

int tcpSrv(int listen_port);
int set_non_block(int fd);

int main(int argc, char* argv[]) {
    tcpSrv(SERV_PORT);
    return 0;
}

int set_non_block(int fd) {
    int fd_fl = fcntl(fd, F_GETFL); 
    fd_fl |= O_NONBLOCK;
    if (fcntl(fd, F_SETFL, fd_fl) < 0) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listenfd) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    set_non_block(listenfd);

    struct epoll_event ev;
    ev.data.fd = listenfd;
    ev.events = EPOLLIN|EPOLLET;
    int epfd = epoll_create(4096);
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    struct sockaddr_in serveraddr;
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char* local_addr = "127.0.0.1";
    inet_aton(local_addr, &(serveraddr.sin_addr));
    serveraddr.sin_port = htons(listen_port);

    if (bind(listenfd, (sockaddr*)&serveraddr, sizeof(serveraddr)) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }
    
    if (listen(listenfd, LISTENQ) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }

    struct epoll_event events[MAX_EVENTS];
    //struct sockaddr_in clientaddr;
    //socklen_t clilen;
    while (1) {
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, EP_TIMEOUT);
        //printf("events count:%d\n", nfds);
        for (int i=0; i<nfds; i++) {
            if (events[i].data.fd == listenfd) {
                while (1) {
                    int connfd = accept(listenfd, NULL, NULL);
                    if (connfd < 0) {
                        //printf("%d\n:", __LINE__);perror(__FILE__);
                        break;
                    }
                    //char *str_client_addr = inet_ntoa(clientaddr.sin_addr);
                    //cout<<"accept a connection from: "<<str_client_addr<<endl;
                    ev.data.fd = connfd;
                    ev.events = EPOLLIN | EPOLLET;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
                }
            } else if (events[i].events & EPOLLIN) {
                //cout<<"EPOLLIN"<<endl;
                int sockfd = events[i].data.fd;
                if (sockfd < 0) {
                    printf("%d\n:", __LINE__);perror(__FILE__);
                    continue;
                }
                char buffer[MAX_LINE+1];
                memset(buffer, 0, sizeof(buffer));
                read(sockfd, buffer, MAX_LINE);
                //printf("%s\n", buffer);
                set_non_block(sockfd);
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\n<html>epoll</html>";
                write(sockfd, html_resp, strlen(html_resp));
                epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
                close(sockfd);
            }
        }
    }
    
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.474 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13380.33 [#/sec] (mean)
Time per request:       0.075 [ms] (mean)
Time per request:       0.075 [ms] (mean, across all concurrent requests)
Transfer rate:          483.47 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       5
Waiting:        0    0   0.0      0       5
Total:          0    0   0.0      0       5

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      5 (longest request)

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.991 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16691.90 [#/sec] (mean)
Time per request:       0.599 [ms] (mean)
Time per request:       0.060 [ms] (mean, across all concurrent requests)
Transfer rate:          603.13 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       7
Waiting:        0    0   0.1      0       6
Total:          0    1   0.2      1       7

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      7 (longest request)

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   6.233 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16043.99 [#/sec] (mean)
Time per request:       6.233 [ms] (mean)
Time per request:       0.062 [ms] (mean, across all concurrent requests)
Transfer rate:          579.71 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   1.0      1       9
Processing:     1    5   0.9      5      12
Waiting:        1    2   0.9      2      10
Total:          2    6   1.4      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      7
  75%      7
  80%      7
  90%      8
  95%      8
  98%     10
  99%     10
 100%     15 (longest request)

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   7.099 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    14087.17 [#/sec] (mean)
Time per request:       70.987 [ms] (mean)
Time per request:       0.071 [ms] (mean, across all concurrent requests)
Transfer rate:          509.01 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        1   26 115.1     19    3054
Processing:    16   44   9.7     43      76
Waiting:        1   18   8.0     18      54
Total:         20   70 115.7     65    3103

Percentage of the requests served within a certain time (ms)
  50%     65
  66%     73
  75%     79
  80%     82
  90%     89
  95%     95
  98%    101
  99%    106
 100%   3103 (longest request)
linux:~/ab/httpd-2.4.3/support$

可以看到 epoll 确实是很猛的，这里有一个地方需要注意，我调了两天，就是在 epoll 的 EPOLLIN 事件发生在 listenfd 上的时候，这个时候需要去 accept，这个应该都没有什么问题，但是我一开始只是 accept 了一个，而实际上，这个时候，是可能有多个连接在等待 accept 的，于是就导致了并发能力很不行，正确的做法应该是一直 accept，直到没有东西可以 accept 了，这样才能有并发能力。

字符串距离

Sat, 13 Oct 2012 18:26:16 +0800

今天见到一个题，让求两个字符串之间的距离，隐约记得之前在 php 中用过这个的现成函数，当时还查了一下原理，是一个俄罗斯的人搞的一个算法，原理是用矩阵，于是就往矩阵上去想，结果没想出来，后来听同学说那是个 dp，想想也是，唉，思路狭隘了

参考这里，http://www.java3z.com/cwbwebhome/article/article5/51329.html?id=4197，写了一个矩阵的版本，写的时候注意一下二维数组的操作

#include <stdio.h>
#include <string.h>

inline int min(int a, int b, int c) {
	if (a<=b && a<=c) {
		return a;
	} else if (b<=a && b<=c) {
		return b;
	} else {
		return c;
	}
}

int ld(char *str1, char *str2) {
	int len1=strlen(str1), len2=strlen(str2);
	if (len1 == 0) {
		return len2;
	}
	if (len2 == 0) {
		return len1;
	}
	int **d;

	// create 2d array
	d = new int*[len1+1];
	for (int i=0; i<len1+1; i++) {
		d[i] = new int[len2+1];
	}

	// init 2d array
	for (int i=0; i<len1+1; i++) {
		d[i][0] = i;
	}
	for (int i=0; i<len2+1; i++) {
		d[0][i] = i;
	}

	// Levenshtein distance
	for (int i=1; i<=len1; i++) {
		for (int j=1; j<=len2; j++) {
			int is_diff = 0;
			if (str1[i-1] == str2[j-1]) {
				is_diff = 0;
			} else {
				is_diff = 1;
			}
			d[i][j] = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+is_diff);
		}
	}
	int ans = d[len1][len2];

	// delete 2d array
	for (int i=0; i<len1+1; i++) {
		delete[] d[i];
	}
	delete[] d;
	d = NULL;

	return ans;
}

int main() {
	char str1[] = "bambol";
	char str2[] = "umbo";
	printf("%dn", ld(str1, str2));
	return 0;
}

可以看到说是矩阵其实还是有 dp 的影子的

栈结构练习

Fri, 14 Sep 2012 11:12:03 +0800

今天从刘汝佳的书上看到一个简单的栈的题目

有n节车厢从A方向驶入车站，按进站顺序编号1～n。现让这些火车按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，可以借助中转站C。C是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的车厢必须按照相反的顺序驶出C。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了请编程判断判断：按给定的出站顺序，火车能否出站

用 c++ 的 stl 写的话是这样

#include <cstdio>
#include <stack>

using namespace std;

int main()
{
	int n;
	while (scanf("%d", &n) == 1)
	{
		int *target = new int[n+1];
		for (int i=1; i<=n; i++)
		{
			scanf("%d", &target[i]);
		}
		stack<int> s;
		int a=1, b=1, ok=1;
		while (b < n)
		{
			if (a == target[b])
			{
				a++;
				b++;
			}
			else if ( !s.empty() && s.top()==target[b])
			{
				s.pop();
				b++;
			}
			else if (a < n)
			{
				s.push(a);
				a++;
			}
			else
			{
				ok = 0;
				break;
			}
		}
		delete[] target;
		target = NULL;
		if (ok)
		{
			printf("Yesn");
		}
		else
		{
			printf("Non");
		}
	}
	return 0;
}

输入输出

5
1 2 3 4 5
Yes
5
5 4 1 2 3
No
6
6 5 4 3 2 1
Yes

KMP 串匹配

Thu, 13 Sep 2012 16:55:51 +0800

昨天一天没有写出代码来，惭愧惭愧，昨天在看红黑树和堆排序，可惜最后都没有能写出东西来，渐渐的感觉网络上的中文资料不太可以依赖了啊，要么就是没有，要么就是 google 出来排名在前面的都会写错，看来要么转向英文资料，要么转向纸质书了

今天参考这里，http://blog.csdn.net/v_july_v/article/details/7041827，写了个 KMP 串匹配，感觉 KMP 也是网络上的中文资料好多错的，而且讲的也繁杂，看了好久都没有能够讲清楚

#include <iostream>
#include <string>

using namespace std;

int kmp(const string &target, const string &pattern)
{
	const int tar_len = target.size();
	const int pat_len = pattern.size();

	// 构造 next 数组
	int *next = new int[pat_len];
	next[0] = -1;
	int index = 0;
	for (int i=1; i<pat_len; i++)
	{
		index = next[i-1];
		while (index>=0 && pattern[index+1]!=pattern[i])
		{
			index = next[index];
		}
		if (pattern[index+1] == pattern[i])
		{
			next[i] = index + 1;
		}
		else
		{
			next[i] = -1;
		}
	}

	// KMP 匹配
	int par_index = 0;
	int tar_index = 0;
	while (par_index<pat_len && tar_index<tar_len)
	{
		if (target[tar_index] == pattern[par_index])
		{
			tar_index++;
			par_index++;
		}
		else if (par_index == 0)
		{
			tar_index++;
		}
		else
		{
			par_index = next[par_index-1] + 1;
		}
	}

	delete[] next;

	if(par_index == pat_len)
	{
		return tar_index-par_index;
	}
	else
	{
		return -1;
	}
}

int main()
{
	string target = "ababc";
	string pattern = "abc";
	cout<<kmp(target, pattern)<<endl;
	return 0;
}

输入输出

1亿以内的回文质数

Tue, 11 Sep 2012 19:57:25 +0800

今天下午看到这么一个题

找出 1 亿以内的回文质数

很自然的思路就是素数筛，然后验证回文性质

#include <iostream>
#include <cmath>
#include <ctime>

#define TOTAL 100000000

using namespace std;

bool is_prime[TOTAL];

void Sieve_of_Eratosthenes()
{
	memset(is_prime, 1, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	for (int i=2; i<sqrt(TOTAL+0.5); i++)
	{
		if (is_prime[i])
		{
			for (int j=i*i; j<TOTAL; j+=i)
			{
				is_prime[j] = false;
			}
		}
	}
}

void test_palin()
{
	for (int i=2; i<TOTAL; i++)
	{
		if (is_prime[i])
		{
			int cpy = i, sum;
			for (sum=0; cpy!=0; cpy/=10)
			{
				sum = sum*10 + cpy%10;
			}
			if (sum == i)
			{
				printf("%dn", i);
			}
		}
	}
}

int main()
{
	Sieve_of_Eratosthenes();
	test_palin();
	printf("%lfn", (double)clock()/CLOCKS_PER_SEC);
	return 0;
}

上面这个素数筛在我的电脑上跑需要 4.07 秒，加上验证函数，耗时在 5.0 秒左右波动

思路是没错，但是略慢了，可以看到主要时间耗在打表上，上网翻看了一下，http://wenku.baidu.com/view/8ee7ce7301f69e31433294e7.html，别人的思路不是打表，而是先判断回文，再判断质数，而是质数判断就直接穷举去除，看到他的最好的方法方法四是 0.5 秒，于是照着这个思路，重新搞，简单分析可以知道，任何一个 k 位正整数都可以产生一个 2*k 位和一个 2*k-1 位两个回文整数，例如，12 可以产生 121 和 1221 这两个，然后我们又知道，1 亿以内最大的数就是 99999999 了，8 个 9，那产生的时候最大也就 4 位数就可以了，照着这个思路，得到如下代码

#include <stdio.h>
#include <math.h>
#include <time.h>

int is_prime(int x)
{
	for (int i=2; i<sqrt(x+0.5); i++)
	{
		if (x%i == 0)
		{
			return 0;
		}
	}
	return 1;
}

void gener_palin()
{
	for (int i=1; i<10000; i++)
	{
		// 根据 k 位数 i 产生 2*k 位的回文数
		int cpy = i, sum;
		for (sum=i; cpy!=0; cpy/=10)
		{
			sum = sum*10 + cpy%10;
		}
		if (is_prime(sum))
		{
			printf("%dn", sum);
		}

		// 产生 2*k-1 位的回文数
		cpy = i/10;
		for (sum=i; cpy!=0; cpy/=10)
		{
			sum = sum*10 + cpy%10;
		}
		if (is_prime(sum))
		{
			printf("%dn", sum);
		}
	}
}

int main()
{
	gener_palin();
	printf("%lfn", (double)clock()/CLOCKS_PER_SEC);
	return 0;
}

这个代码在我的机子上可以跑到 0.25 秒，如图

根据经验，卷屏输出是耗时大户，把 29 和 40 行注释掉，可以跑到 0.03 秒

用有序二叉树来统计单词

Tue, 11 Sep 2012 11:47:26 +0800

今天上午看到一个题

本程序从正文文件text.in读入一篇英文短文,统计该短文中不同单词和它的出现次数,并按词典编辑顺序将单词及它的出现次数输出到正文文件word.out中.程序用一棵有序二叉树存储这些单词及其出现的次数,一边读入一边建立.然后中序遍历该二叉树,将遍历经过的二叉树上的节点的内容输出.

搞了一会，代码如下

#include <iostream>
#include <fstream>
#include <string>
#include <memory>

using namespace std;

class Tree
{
public:
	char word[100];
	int count;
	Tree *left;
	Tree *right;

	Tree()
	{
		memset(word, 0, sizeof(word));
		count = 0;
		left = NULL;
		right = NULL;
	}

	void in_order_visit(Tree *t, ofstream &word_out)
	{
		if (t)
		{
			t->in_order_visit(t->left, word_out);
			word_out<<t->word<<endl<<t->count<<endl;
			t->in_order_visit(t->right, word_out);
		}
	}

	void insert_word(char *word)
	{
		if (strlen(this->word) == 0)
		{
			strcpy(this->word, word);
			this->count = 1;
		}
		else
		{
			if (strcmp(word, this->word) < 0)
			{
				if ( ! this->left)
				{
					this->left = new Tree();
					this->left->insert_word(word);
				}
				else
				{
					if (strcmp(word, this->left->word) <= 0)
					{
						this->left->insert_word(word);
					}
					else
					{
						Tree *tmp = new Tree();
						strcpy(tmp->word, word);
						tmp->count = 1;
						tmp->left = this->left;
						this->left = tmp;
					}
				}
			}
			else if (strcmp(word, this->word) == 0)
			{
				this->count++;
			}
			else
			{
				if ( ! this->right)
				{
					this->right = new Tree();
					this->right->insert_word(word);
				}
				else
				{
					if (strcmp(word, this->right->word) >= 0)
					{
						this->right->insert_word(word);
					}
					else
					{
						Tree *tmp = new Tree();
						strcpy(tmp->word, word);
						tmp->count = 1;
						tmp->right = this->right;
						this->right = tmp;
					}
				}
			}
		}
	}
};

int get_text(const char *filename)
{
	FILE *fp = fopen(filename, "r");
	if ( ! fp)
	{
		return 1;
	}
	int in_word = 0;
	char tmp, word[100]={0};
	int word_append_count = 0;
	Tree *t = new Tree();
	while (fscanf(fp, "%c", &tmp) != EOF)
	{
		if ((tmp>='a' && tmp<='z') || (tmp>='A' && tmp<='Z') || tmp==''')
		{
			if (in_word)
			{
				word[word_append_count++] = tmp;
			}
			else
			{
				memset(word, 0, sizeof(word));
				word_append_count = 0;
				word[word_append_count++] = tmp;
				in_word = 1;
			}
		}
		else
		{
			if (strlen(word) > 0)
			{
				t->insert_word(word);
				memset(word, 0, sizeof(word));
				in_word = 0;
			}
		}
	}
	fclose(fp);

	ofstream word_out;
	word_out.open("word.out", ios::app);
	t->in_order_visit(t, word_out);
	word_out.close();
}

int main()
{
	get_text("text.in");
	return 0;
}

没有考虑内存释放，罪过罪过

输入的文本是从 google news 上面随便摘的一段

Chicago teachers take to the picket lines for the first time in 25 years in dispute over Mayor Rahm Emanuel's longer school day, job security and class size. WSJ's Caroline Porter and Douglas Belkin report. Photo: AP.
CHICAGO—Teachers in the third-largest U.S. school district went on strike Monday, halting classes for about 350,000 students and casting an election-season spotlight on a growing national debate over how best to evaluate teachers, set their pay and fire them.

Months of acrimonious contract negotiations between the Chicago Teachers Union and Mayor Rahm Emanuel stalled this weekend, apparently over Mr. Emanuel's push to make teacher evaluations more reliant on student performance, and union efforts to preserve job security for teachers who are laid off, two issues driving public school reform battles.

输出

AP
1
Belkin
1
CHICAGO
1
Caroline
1
Chicago
2
Douglas
1
Emanuel
1
Emanuel's
2
Mayor
2
Monday
1
Months
1
Mr
1
Photo
1
Porter
1
Rahm
2
S
1
Teachers
2
U
1
Union
1
WSJ's
1
a
1
about
1
acrimonious
1
an
1
and
6
apparently
1
are
1
battles
1
best
1
between
1
casting
1
class
1
classes
1
contract
1
day
1
debate
1
dispute
1
district
1
driving
1
efforts
1
election
1
evaluate
1
evaluations
1
fire
1
first
1
for
3
growing
1
halting
1
how
1
in
3
issues
1
job
2
laid
1
largest
1
lines
1
longer
1
make
1
more
1
national
1
negotiations
1
of
1
off
1
on
3
over
3
pay
1
performance
1
picket
1
preserve
1
public
1
push
1
reform
1
reliant
1
report
1
school
3
season
1
security
2
set
1
size
1
spotlight
1
stalled
1
strike
1
student
1
students
1
take
1
teacher
1
teachers
3
the
4
their
1
them
1
third
1
this
1
time
1
to
4
two
1
union
1
weekend
1
went
1
who
1
years
1

二叉树的遍历

Sat, 08 Sep 2012 17:01:31 +0800

参考 http://blog.csdn.net/acdnjjjdjkdckjj/article/details/6237970 写了二叉树的遍历，（基本上就是照抄的，囧），抄的时候感慨，stl 真是个好东西啊，另外，在三种次序遍历的实现上，递归的精巧发挥的淋漓尽致啊，还有就是非递归的遍历，设计真的好巧妙

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

class Tree
{
public:
	char data;
	Tree *left;
	Tree *right;
	void create(Tree *&node);
	void preOrderVisit(Tree *node);
	void inOrderVisit(Tree *node);
	void lastOrderVisit(Tree *node);
	void levelOrderVisit(Tree *node);
	void notRecursionPreOrderVisit(Tree *node);
	void notRecursionInorderVisit(Tree *node);
	void notRecursionLastOrderVisit(Tree *node);
};

void Tree::create(Tree *&node)
{
	char ch;
	cin>>ch;
	if (ch == '0')
	{
		node = NULL;
	}
	else
	{
		node = new Tree();
		node->data = ch;
		create(node->left);
		create(node->right);
	}
}

void Tree::preOrderVisit(Tree *node)
{
	if (node)
	{
		cout<<node->data<<' ';
		preOrderVisit(node->left);
		preOrderVisit(node->right);
	}
}

void Tree::inOrderVisit(Tree *node)
{
	if (node)
	{
		inOrderVisit(node->left);
		cout<<node->data<<' ';
		inOrderVisit(node->right);
	}
}

void Tree::lastOrderVisit(Tree *node)
{
	if (node)
	{
		lastOrderVisit(node->left);
		lastOrderVisit(node->right);
		cout<<node->data<<' ';
	}
}

void Tree::levelOrderVisit(Tree *node)
{
	if ( ! node)
	{
		return;
	}
	queue<Tree *> q;
	q.push(node);
	while ( ! q.empty())
	{
		Tree *tmp = q.front();
		cout<<tmp->data<<' ';
		q.pop();
		if (tmp->left)
		{
			q.push(tmp->left);
		}
		if (tmp->right)
		{
			q.push(tmp->right);
		}
	}
}

void Tree::notRecursionPreOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			cout<<t->data<<' ';
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			t = t->right;
		}
	}
}

void Tree::notRecursionInorderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			cout<<t->data<<' ';
			t = t->right;
		}
	}
}

void Tree::notRecursionLastOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	Tree *pre = NULL;
	while(!s.empty() || t)
	{
		while (t)
		{
			s.push(t);
			t = t->left;
		}
		t = s.top();
		if (t->right==NULL || t->right==pre)
		{
			cout<<t->data<<' ';
			pre = t;
			t = NULL;
			s.pop();
		}
		else
		{
			t = t->right;
		}
	}
}

int main()
{
	Tree *t = NULL;
	t->create(t);
	t->preOrderVisit(t);
	cout<<endl;
	t->inOrderVisit(t);
	cout<<endl;
	t->lastOrderVisit(t);
	cout<<endl;
	t->levelOrderVisit(t);
	cout<<endl;
	t->notRecursionPreOrderVisit(t);
	cout<<endl;
	t->notRecursionInorderVisit(t);
	cout<<endl;
	t->notRecursionLastOrderVisit(t);
	cout<<endl;
	return 0;
}

输入输出

124005003600700
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
1 2 3 4 5 6 7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1

链表的反转

Sat, 08 Sep 2012 12:19:13 +0800

今天上午自己写了一个链表的反转

#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
	int n;
	_node *next;
} node;

int create_link(node **phead)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	*phead = (node *)malloc(sizeof(node));
	if ( ! *phead)
	{
		return 1;
	}
	(*phead)->n = x;
	(*phead)->next = NULL;
	node *now = *phead;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

void print_link(node *head)
{
	node *now = head;
	while (now)
	{
		printf("%d", now->n);
		if (now->next)
		{
			printf(" -> ");
		}
		now = now->next;
	}
	printf("n");
}

void delete_link(node **head)
{
	node *now = *head;
	while (now)
	{
		node *tmp = now->next;
		free(now);
		now = tmp;
	}
	*head = NULL;
}

void reverse_link(node **phead)
{
	node *pre = *phead;
	node *curr = pre->next;
	if ( ! curr)
	{
		// 只有一个节点
		return;
	}
	node *next = curr->next;
	pre->next = NULL;
	while (1)
	{
		curr->next = pre;
		if (next)
		{
			pre = curr;
			curr = next;
			next = next->next;
		}
		else
		{
			break;
		}
	}
	*phead = curr;
}

int main()
{
	node *head = NULL;
	create_link(&head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

输入输出

input nums, press Ctrl+Z(win) or Ctrl+D(linux) to end
3 1 2 4 0
^Z
3 -> 1 -> 2 -> 4 -> 0
0 -> 4 -> 2 -> 1 -> 3

==================================================

2012-09-08 12:39:03 update 参考这里 http://blog.csdn.net/rerli/article/details/19038，反转函数有更简单的写法

void reverse_link(node **phead)
{
	node *pre = NULL;
	node *curr = *phead;
	node *next = NULL;
	while (curr)
	{
		next = curr->next;
		curr->next = pre;
		pre = curr;
		curr = next;
	}
	*phead = pre;
}

================================================

参考这里，http://blog.csdn.net/rerli/article/details/19039，写了链表的插入排序

void insert_sort(node **phead)
{
	node *head = *phead;
	// 把 head 的下一节点保存起来
	node *first = head->next;
	// 断开 head，使其成为初始的有序链表
	head->next = NULL;
	while (first)
	{
		node *p, *q, *t;
		// 找到插入点
		for (t=first, q=head; q && q->n < t->n; p=q, q=q->next);
		// 把 first 节点从无序链表中断开
		first = first->next;

		if (q == head)
		{
			// 插入在头结点之前
			head = t;
		}
		else
		{
			// p 是 q 的前驱
			p->next = t;
		}
		t->next = q;
	}
	*phead = head;
}

======================================================

2012-09-08 15:02:07 update 相比于传二维指针，可以使用 c++ 的写法，传引用，这样可读性会高很多

int create_link(node *&head)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	head = (node *)malloc(sizeof(node));
	if ( ! head)
	{
		return 1;
	}
	head->n = x;
	head->next = NULL;
	node *now = head;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

调用的时候改成

int main()
{
	node *head = NULL;
	create_link(head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	insert_sort(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

虚函数与纯虚函数

Thu, 06 Sep 2012 10:14:00 +0800

虚函数的作用是在父类中定义函数时，尚未知道由哪个子类来调用的情况下，提供一种自动指向，有点类似 java 的向上转型的意思，还是看代码吧，如果没有使用虚函数

#include <iostream>

using namespace std;

class animal
{
public:
	void shout()
	{
		cout<<"animal"<<endl;
	}
	void call_shout(animal *a)
	{
		a->shout();
	}
};
class dog : public animal
{
public:
	void shout()
	{
		cout<<"wang"<<endl;
	}
};
int main()
{
	animal a;
	dog d;
	a.call_shout(&d);
}

输出是

animal

使用虚函数之后

#include <iostream>

using namespace std;

class animal
{
public:
	virtual void shout()
	{
		cout<<"animal"<<endl;
	}
	void call_shout(animal *a)
	{
		a->shout();
	}
};
class dog : public animal
{
public:
	void shout()
	{
		cout<<"wang"<<endl;
	}
};
int main()
{
	animal a;
	dog d;
	a.call_shout(&d);
}

输出是

wang

至于纯虚函数，就是父类只声明，不定义，留给子类去定义，有点像 java 的 interface

#include <iostream>

using namespace std;

class animal
{
public:
	virtual void shout() = 0;
};
class dog : public animal
{
public:
	void shout()
	{
		cout<<"dog"<<endl;
	}
};
class cat : public animal
{
public:
	void shout()
	{
		cout<<"cat"<<endl;
	}
};
int main()
{
	dog d;
	d.shout();
	cat c;
	c.shout();
}

输出是

dog
cat

另外，关于这个内容，这里有篇文章写的不错，http://www.cnblogs.com/MS-Frank/archive/2008/01/16/1041310.html