「探索 Linux 网络编程：socket 多线程」 (linux socket多线程)
探索 Linux 网络编程：socket 多线程
Linux 是基于开源的操作系统，它的网络编程能力非常强大。为了更好地理解 Linux 网络编程，我们需要探索 Socket 多线程技术，这种技术可以提高网络应用的性能和并发连接的能力。
今天，本文将介绍 Socket 多线程的工作原理和实现方法，在实际项目中如何运用 Socket 多线程技术，以及 Socket 多线程的优势和限制。
什么是 Socket 多线程？
Socket 是一种网络通信协议，可以用于实现客户端和服务器之间的通信。我们可以使用 Linux 的 Socket 编程接口进行网络编程。多线程是一种并发编程方式，我们可以通过创建多个线程来并发执行任务，从而提高应用程序的性能和效率。
因此，Socket 多线程是指在 Linux 环境下，通过创建多个线程来实现 Socket 通信的并发连接能力，以提高网络应用的性能和效率。
Socket 多线程的工作原理
Socket 多线程的工作原理主要分为两个阶段：初始化和执行。
初始化阶段：
1.创建 Socket：在服务器端创建一个 Socket，并监听指定端口，等待客户端连接。
2.创建线程池：在服务器端创建一个线程池，用于存放多个工作线程。
3.创建工作线程：在线程池中创建多个工作线程，等待任务分配。
4.等待客户端连接：服务器进入等待状态，等待客户端连接。
执行阶段：
1.客户端连接：当一个客户端连接到服务器端时，服务器接受连接请求，并将客户端 Socket 指派到一个工作线程。
2.工作线程处理任务：工作线程从任务队列中获取任务，并执行任务，处理客户端请求。
3.任务完成：当工作线程完成任务后，将任务返回给线程池，并等待下一个任务分配。
4.断开连接：当客户端下线时，服务器端断开连接，释放资源。
Socket 多线程的实现方法
在 Linux 环境下，我们可以使用 C/C++ 等编程语言实现 Socket 多线程。下面是一个基于 C++ 实现 Socket 多线程的示例：
“`c++
class Thread {
public:
Thread();
virtual ~Thread();
virtual void Run();
void Start();
void Stop();
void Join();
bool IsRunning() const;
pthread_t GetThreadId() const;
protected:
bool m_running;
pthread_t m_threadId;
static void* StartThread(void* arg);
};
class ThreadPool {
public:
ThreadPool(int size);
~ThreadPool();
void AddTask(Task* task);
private:
int m_size;
bool m_stop;
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;
std::vector m_tasks;
std::vector m_threads;
void Initialize();
void Finalize();
void CreateThreads();
void DestroyThreads();
};
class Task {
public:
virtual void Run() = 0;
};
class SocketTask : public Task {
public:
SocketTask(int sockfd);
virtual ~SocketTask();
virtual void Run();
private:
int m_sockfd;
};
“`
上述代码中，我们定义了三个类：Thread、Task 和 ThreadPool。Thread 类是一个封装了 POSIX 线程的类，它可以启动一个新线程，并执行线程回调函数；Task 类是一个封装了执行任务的类，它必须继承 Run() 函数；ThreadPool 类是一个封装了一个线程池的类，它可以添加任务、初始化线程池、创建多个工作线程等。
在实际项目中如何运用 Socket 多线程技术
在实际项目中，我们可以通过以下步骤来运用 Socket 多线程技术：
1.在服务器端创建 Socket，并监听指定端口，等待客户端连接。
2.当客户端连接服务器时，将客户端 Socket 分配给一个工作线程。
3.工作线程从任务队列中获取任务，并执行任务，处理客户端请求。
4.当客户端下线时，服务器端断开连接，释放资源。
通过 Socket 多线程技术，我们可以提高服务器端的并发处理能力，加快网络应用的响应速度，同时提高系统的可靠性和稳定性。
Socket 多线程的优势和限制
Socket 多线程技术的优势和限制如下：
优势：
1.提高应用程序的性能和效率：多线程可以并发执行任务，提高应用程序的性能和效率，减少响应时间。
2.提高并发连接能力：通过多线程技术，服务器可以处理多个连接，提高应用程序的并发连接能力。
3.实现灵活：线程池可以动态管理线程，保证了应用程序的灵活性。
限制：
1.线程安全问题：由于多个线程同时操作共享数据，可能会产生线程安全问题。
2.资源占用问题：多线程需要占用更多的系统资源，包括 CPU、内存资源等，可能会导致系统资源紧张。
3.实现复杂：线程池需要对多个线程进行管理，实现起来较为复杂。
相关问题拓展阅读：
socket编程在windows和linux下的区别
下面大概分几个方面进行罗列：
Linux要包含
#include
#include
#include
#include
等头文件，而windows下则是包含
#include
。
Linux中socket为整形，Windows中为一个SOCKET。
Linux中关闭socket为close，Windows中为closesocket。
Linux中有变量socklen_t，Windows中直接为int。
因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。
设置socet选项，比如设置socket为非阻塞的。Linux下为
flag = fcntl (fd, F_GETFL);
fcntl (fd, F_SETFL, flag | O_NONBLOCK);
，Windows下为
flag = 1;
ioctlsocket (fd, FIONBIO, (unsigned long *) &flag);
。
当非阻塞socket的TCP连接正在进行时，Linux的错误号为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。
file
Linux下面，文件换行是春携仔”\n”，而windows下面是”\r\n”。
Linux下面，目录分隔符是”/”，而windows下面是”\”。
Linux与Windows下面，均可以使用stat调用来查询文件信息。但是，Linux只支持2G大小，而Windows只支持4G大小。为了支持更大的文件查询，可以在隐猜Linux环境下加
_FILE_OFFSET_BITS=64定义，在Windows下面使用_stat64调用，入参为struct __stat64。
Linux中可根据stat的st_mode判断文件类型，有S_ISREG、S_ISDIR等宏。Windows中没有，需要自己定义相应的宏，如
#define S_ISREG(m) (((m) &) == ())
#define S_ISDIR(m) (((m) &) == ())
Linux中删除文件是unlink，Windows中为DeleteFile。
time
Linux中，time_t结构是长整形。而windows中，time_t结构是64位的整形。如果要在windows始time_t为32位无符号整形，可以加宏定义，_USE_32BIT_TIME_T。
Linux中，sleep的单位为秒。Windows中，Sleep的单位为毫秒。即，Linux下sleep (1)，在Windows环境下则需要Sleep (1000)。
Windows中的timecmp宏，不支持大于等于或者小于等于。
Windows中没有struct timeval结构的加减宏可以使用，需要手动定义：
#define MICROSECONDS (1000 * 1000)
#define timeradd(t1, t2, t3) do { \
(t3)->tv_sec = (t1)->tv_sec + (t2)->tv_sec; \
(t3)->tv_usec = (t1)->tv_usec + (t2)->tv_usec % MICROSECONDS;\
if ((t1)->tv_usec + (t2)->tv_usec > MICROSECONDS) (t3)->tv_sec ++;\
扒汪 } while (0)
#define timersub(t1, t2, t3) do { \
(t3)->tv_sec = (t1)->tv_sec – (t2)->tv_sec; \
(t3)->tv_usec = (t1)->tv_usec – (t2)->tv_usec; \
if ((t1)->tv_usec – (t2)->tv_usec tv_usec –, (t3)->tv_usec += MICROSECONDS; \
} while (0)
调用进程
Linux下可以直接使用system来调用外部程序。Windows更好使用WinExec，因为WinExec可以支持是打开还是隐藏程序窗口。用WinExec的第二个入参指明，如
SW_SHOW/SW_HIDE。
杂项
Linux为srandom和random函数，Windows为srand和rand函数。
Linux为snprintf，Windows为_snprintf。
同理，Linux中的strcasecmp，Windows为_stricmp。
错误处理
Linux下面，通常使用全局变量errno来表示函数执行的错误号。Windows下要使用GetLastError ()调用来取得。
Linux环境下仅有的
这些函数或者宏，Windows中完全没有，需要用户手动实现。
atoll
long long
atoll (const char *p)
{
int minus = 0;
long long value = 0;
if (*p == ‘-‘)
{
minus ++;
p ++;
}
while (*p >= ‘0’ && *p tv_sec = (long) (t /);
tv->tv_usec = (long) (t %);
}
if (tz)
{
if (!tzflag)
{
_tzset ();
tzflag++;
}
tz->tz_minuteswest = _timezone / 60;
tz->tz_dsttime = _daylight;
}
return 0;
}
编译相关
当前函数，Linux用__FUNCTION__表示，Windows用__func__表示。
Socket 编程 windows到Linux代码移植遇到的问题
1)头文件
windows下winsock.h/winsock2.h
linux下sys/socket.h
错误处理：errno.h
2)初始化
windows下需要用WSAStartup
linux下不需要
3)关闭socket
windows下closesocket(…)
linux下close(…)
4)类型
windows下SOCKET
linux下int
如我用到的一些宏：
#ifdef WIN32
typedef int socklen_t;
typedef int ssize_t;
#endif
#ifdef __LINUX__
typedef int SOCKET;
typedef unsigned char BYTE;
typedef unsigned long DWORD;
#define FALSE 0
#define SOCKET_ERROR (-1)
#endif
5)获取错误码
windows下getlasterror()/WSAGetLastError()
linux下errno变量
6)设置非阻塞
windows下ioctlsocket()
linux下fcntl()
7)send函数最后一个参数
windows下一般设置为0
linux下更好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可 能会导致程序退出。
8)毫秒级时间获取
windows下GetTickCount()
linux下gettimeofday()
3、多线程
多线程: (win)process.h –〉(linux)pthread.h
_beginthread –> pthread_create
_endthread –> pthread_exit
windows与linux平台使用的socket均继承自Berkeley socket(rfc3493)，他们都支持select I/O模型，均支持使用getaddrinfo与getnameinfo实现协议无关编程。但存在细微差别，
主要有：
头文件及类库。windows使用winsock2.h(需要在windows.h前包含)，并要链接库ws2_32.lib；linux使用netinet/in.h, netdb.h等。
windows下在使用socket之前与之后要分别使用WSAStartup与WSAClean。
关闭socket，windows使用closesocket，linux使用close。
send*与recv*函数参数之socket长度的类型，windows为int，linux为socklen_t，可预编译指令中处理这一差异，当平台为windows时#define socklen_t unsigned int。
select函数之一个参数，windows忽略该参数，linux下该参数表示中socket的上限值，一般设为sockfd(需select的socket) + 1。
windows下socket函数返回值类型为SOCKET(unsigned int)，其中发生错误时返回INVALID_SOCKET(0)，linux下socket函数返回值类型int, 发生错误时返回-1。
另外，如果绑定本机回环地址，windows下sendto函数可以通过，linux下sendto回报错：errno=22, Invalid arguement。一般情况下均绑定通配地址。
转载jlins
下面大概分几个方面进行罗列:
Linux要包含
#include
#include
#include
#include
等头文件，而windows下则是包含
#include
。
Linux中socket为整形，Windows中为一个SOCKET。
Linux中关闭socket为close，Windows中为closesocket。
Linux中有变量socklen_t，Windows中直接为int。
因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。
设置socet选项，比如设置socket为非阻塞的。Linux下为
flag = fcntl (fd， F_GETFL)；
fcntl (fd， F_SETFL， flag | O_NONBLOCK)；
，Windows下为
flag = 1；
ioctlsocket (fd， FIONBIO， (unsigned long *) &flag)；
。
当非阻塞socket的TCP连接正在进行时，Linux的错误号竖笑为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。
file
Linux下面，文件换行是”\n”，而windows下面是”\r\n”。
Linux下面，目录分隔符是”/”，而windows下面是”\”。
Linux与Windows下面，均可以使用stat调用来查询文件信息。但是，Linux只支持2G大小，而Windows只支持4G大小。为了支持更大的文件查询，可以在Linux环境下加
_FILE_OFFSET_BITS=64定义，在Windows下面使用_stat64调用，入参为struct __stat64。
Linux中可根据stat的st_mode判断文件类型，有S_ISREG、S_ISDIR等宏。罩圆Windows中没有，需要自己定义相应的宏，如
#define S_ISREG(m) (((m) &) == ())
#define S_ISDIR(m) (((m) &) == ())
Linux中删除文件是unlink，Windows中为DeleteFile。
time
Linux中，time_t结构是长整形。而windows中，time_t结构是64位的整形。如果要在windows始time_t为32位无符号整形，可以加宏定义，_USE_32BIT_TIME_T。
Linux中，sleep的单位为秒。Windows中，Sleep的单位为毫秒。即，Linux下sleep (1)，在Windows环境下则需要Sleep (1000)。
Windows中的timecmp宏，不支持大于等于或者余闷含小于等于。
Windows中没有struct timeval结构的加减宏可以使用，需要手动定义:
#define MICROSECONDS (1000 * 1000)
#define timeradd(t1， t2， t3) do { \
(t3)->tv_sec = (t1)->tv_sec + (t2)->tv_sec； \
(t3)->tv_usec = (t1)->tv_usec + (t2)->tv_usec % MICROSECONDS；\
if ((t1)->tv_usec + (t2)->tv_usec > MICROSECONDS) (t3)->tv_sec ++；\
} while (0)
#define timersub(t1， t2， t3) do { \
(t3)->tv_sec = (t1)->tv_sec – (t2)->tv_sec； \
(t3)->tv_usec = (t1)->tv_usec – (t2)->tv_usec； \
if ((t1)->tv_usec – (t2)->tv_usec tv_usec –， (t3)->tv_usec += MICROSECONDS； \
} while (0)
调用进程
Linux下可以直接使用system来调用外部程序。Windows更好使用WinExec，因为WinExec可以支持是打开还是隐藏程序窗口。用WinExec的第二个入参指明，如
SW_SHOW/SW_HIDE。
杂项
Linux为srandom和random函数，Windows为srand和rand函数。
Linux为snprintf，Windows为_snprintf。
同理，Linux中的strcasecmp，Windows为_stricmp。
错误处理
Linux下面，通常使用全局变量errno来表示函数执行的错误号。Windows下要使用GetLastError ()调用来取得。
Linux环境下仅有的
这些函数或者宏，Windows中完全没有，需要用户手动实现。
atoll
long long
atoll (const char *p)
{
int minus = 0；
long long value = 0；
if (*p == ‘-‘)
{
minus ++；
p ++；
}
while (*p >= ‘0’ && *p tv_sec = (long) (t /)；
tv->tv_usec = (long) (t %)；
}
if (tz)
{
if (，tzflag)
{
_tzset ()；
tzflag++；
}
tz->tz_minuteswest = _timezone / 60；
tz->tz_dsttime = _daylight；
}
return 0；
}
编译相关
当前函数，Linux用__FUNCTION__表示，Windows用__func__表示。
Socket 编程 windows到Linux代码移植遇到的问题
1)头文件
windows下winsock.h/winsock2.h
linux下sys/socket.h
错误处理:errno.h
2)初始化
windows下需要用WSAStartup
linux下不需要
3)关闭socket
windows下closesocket(…)
linux下close(…)
4)类型
windows下SOCKET
linux下int
如我用到的一些宏:
#ifdef WIN32
typedef int socklen_t；
typedef int ssize_t；
#endif
#ifdef __LINUX__
typedef int SOCKET；
typedef unsigned char BYTE；
typedef unsigned long DWORD；
#define FALSE 0
#define SOCKET_ERROR (-1)
#endif
5)获取错误码
windows下getlasterror()/WSAGetLastError()
linux下errno变量
6)设置非阻塞
windows下ioctlsocket()
linux下fcntl()
7)send函数最后一个参数
windows下一般设置为0
linux下更好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可 能会导致程序退出。
8)毫秒级时间获取
windows下GetTickCount()
linux下gettimeofday()
3、多线程
多线程: (win)process.h –〉(linux)pthread.h
_beginthread –> pthread_create
_endthread –> pthread_exit
windows与linux平台使用的socket均继承自Berkeley socket(rfc3493)，他们都支持select I/O模型，均支持使用getaddrinfo与getnameinfo实现协议无关编程。但存在细微差别，
主要有:
头文件及类库。windows使用winsock2.h(需要在windows.h前包含)，并要链接库ws2_32.lib;linux使用netinet/in.h， netdb.h等。
windows下在使用socket之前与之后要分别使用WSAStartup与WSAClean。
关闭socket，windows使用closesocket，linux使用close。
send*与recv*函数参数之socket长度的类型，windows为int，linux为socklen_t，可预编译指令中处理这一差异，当平台为windows时#define socklen_t unsigned int。
select函数之一个参数，windows忽略该参数，linux下该参数表示中socket的上限值，一般设为sockfd(需select的socket) + 1。
windows下socket函数返回值类型为SOCKET(unsigned int)，其中发生错误时返回INVALID_SOCKET(0)，linux下socket函数返回值类型int， 发生错误时返回-1。
另外，如果绑定本机回环地址，windows下sendto函数可以通过，linux下sendto回报错:errno=22， Invalid arguement。一般情况下均绑定通配地址。
如何看懂《Linux多线程服务端编程
一：进程和线程
每个进程有自己独立的地址空间。“在同一个进程”还是“不在同一个进程”是系统功能划分的重要决策点。《Erlang程序设计》把进程比喻为人：
每个人有自己的记忆（内存），人与人通过谈话（消息传递）来交流，谈话既可以是面谈姿并野（同一台服务器），也可以在里谈（不同的服务器，有网络通信）。面谈和谈的区别在于，面谈可以立即知道对方是否死了（crash,SIGCHLD），而谈只能通过周期性的心跳来判断对方是否还活着。
有了这些比喻，设计分布式系统时可以采取“角色扮演”，团队里的几个人各自扮演一个进程，人的角色由进程的代码决定（管登录的、管消息分发的、管买卖的等等）。每个人有自己的记忆，但不知道别人的记忆，要想知道别人的看法，只能通过交谈（暂不考虑共享内存这种IPC）。然后就可以思考：迹喊
·容错：万一有人突然死了
·扩容：新人中途加进来
·负载均衡：把甲的活儿挪给乙做
·退休：甲要修复bug，先别派新任务，等他做完手上的事情就把他重启
等等各种场景，十分便利。
线程的特点是共享地址空间，从而可以高效地共享数据。一台机器上的多个进程能高效地共享代码段(操作系统可以映射为同样的物理内存)，但不能共享数据。如果多个进程大量共享内存，等于是把多进程程序当成多线程来写，掩耳盗铃。
“多线程”的价值，我认为是为了更好地发挥多核处理器(multi-cores)的效能。在单核时代，多线程没有多大价值（个人想法：如果要完成的任务是CPU密集型的，那多线程没有优势，甚至因为线程切换的开销，多线程反而更慢；如果要完成的任务既有CPU计算，又有磁盘或网络IO，则使用多线程的好处是，当某个线程因为IO而阻塞时，OS可以调度其他线程执行，虽然效率确实要比任务的顺序执行效率要高，然而，这种类型的任务，可以通过单线程的”non-blocking IO+IO multiplexing”的模型（事件驱动）来提高效率，采用多线程的方式，带来的可能仅仅是编程上的简单而已）。Alan Cox说过：”A computer is a state machine.Threads are for people who can’t program state machines.”（计算机是一台状态机。线程是给那些不能编写状态机程序的人准备的）如果只有一块CPU、一个执行单元，那么确实如Alan Cox所说，按状态机的思路去写程序是最蔽谨高效的。
二：单线程服务器的常用编程模型
据我了解，在高性能的网络程序中，使用得最为广泛的恐怕要数”non-blocking IO + IO multiplexing”这种模型，即Reactor模式。
在”non-blocking IO + IO multiplexing”这种模型中，程序的基本结构是一个事件循环（event loop），以事件驱动（event-driven）和事件回调的方式实现业务逻辑：
view plain copy
//代码仅为示意，没有完整考虑各种情况
while(!done)
{
int timeout_ms = max(1000, getNextTimedCallback());
int retval = poll(fds, nfds, timeout_ms);
if (retval0){
处理IO事件，回调用户的IO event handler
}
}
}
这里select(2)/poll(2)有伸缩性方面的不足（描述符过多时，效率较低），Linux下可替换为epoll(4)，其他操作系统也有对应的高性能替代品。
Reactor模型的优点很明显，编程不难，效率也不错。不仅可以用于读写socket，连接的建立(connect(2)/accept(2))，甚至DNS解析都可以用非阻塞方式进行，以提高并发度和吞吐量(throughput)，对于IO密集的应用是个不错的选择。lighttpd就是这样，它内部的fdevent结构十分精妙，值得学习。
基于事件驱动的编程模型也有其本质的缺点，它要求事件回调函数必须是非阻塞的。对于涉及网络IO的请求响应式协议，它容易割裂业务逻辑，使其散布于多个回调函数之中，相对不容易理解和维护。
三：多线程服务器的常用编程模型
大概有这么几种：
a：每个请求创建一个线程，使用阻塞式IO操作。在Java 1.4引人NIO之前，这是Java网络编程的推荐做法。可惜伸缩性不佳（请求太多时，操作系统创建不了这许多线程）。
b：使用线程池，同样使用阻塞式IO操作。与第1种相比，这是提高性能的措施。
c：使用non-blocking IO + IO multiplexing。即Java NIO的方式。
d：Leader/Follower等高级模式。
在默认情况下，我会使用第3种，即non-blocking IO + one loop per thread模式来编写多线程C++网络服务程序。
1：one loop per thread
此种模型下，程序里的每个IO线程有一个event loop，用于处理读写和定时事件（无论周期性的还是单次的）。代码框架跟“单线程服务器的常用编程模型”一节中的一样。
libev的作者说：
One loop per thread is usually a good model. Doing this is almost never wrong, some times a better-performance model exists, but it is always a good start.
这种方式的好处是：
a：线程数目基本固定，可以在程序启动的时候设置，不会频繁创建与销毁。
b：可以很方便地在线程间调配负载。
c：IO事件发生的线程是固定的，同一个TCP连接不必考虑事件并发。
Event loop代表了线程的主循环，需要让哪个线程干活，就把timer或IO channel（如TCP连接）注册到哪个线程的loop里即可：对实时性有要求的connection可以单独用一个线程；数据量大的connection可以独占一个线程，并把数据处理任务分摊到另几个计算线程中（用线程池）；其他次要的辅助性connections可以共享一个线程。
比如，在dbproxy中，一个线程用于专门处理客户端发来的管理命令；一个线程用于处理客户端发来的MySQL命令，而与后端数据库通信执行该命令时，是将该任务分配给所有事件线程处理的。
对于non-trivial（有一定规模）的服务端程序，一般会采用non-blocking IO + IO multiplexing，每个connection/acceptor都会注册到某个event loop上，程序里有多个event loop，每个线程至多有一个event loop。
多线程程序对event loop提出了更高的要求，那就是“线程安全”。要允许一个线程往别的线程的loop里塞东西，这个loop必须得是线程安全的。
在dbproxy中，线程向其他线程分发任务，是通过管道和队列实现的。比如主线程accept到连接后，将表示该连接的结构放入队列，并向管道中写入一个字节。计算线程在自己的event loop中注册管道的读事件，一旦有数据可读，就尝试从队列中取任务。
2：线程池
不过，对于没有IO而光有计算任务的线程，使用event loop有点浪费。可以使用一种补充方案，即用blocking queue实现的任务队列：
view plain copy
typedef boost::functionFunctor;
BlockingQueue taskQueue; //线程安全的全局阻塞队列
//计算线程
void workerThread()
{
while (running) //running变量是个全局标志
{
Functor task = taskQueue.take(); //this blocks
task(); //在产品代码中需要考虑异常处理
}
}
// 创建容量（并发数）为N的线程池
int N = num_of_computing_threads;
for (int i = 0; i task = boost::bind(&Foo::calc，&foo);
taskQueue.post(task);
除了任务队列，还可以用BlockingQueue实现数据的生产者消费者队列，即T是数据类型而非函数对象，queue的消费者从中拿到数据进行处理。其实本质上是一样的。
3：总结
总结而言，我推荐的C++多线程服务端编程模式为：one (event) loop per thread + thread pool：
event loop用作IO multiplexing，配合non-blockingIO和定时器；
thread pool用来做计算，具体可以是任务队列或生产者消费者队列。
以这种方式写服务器程序，需要一个优质的基于Reactor模式的网络库来支撑，muduo正是这样的网络库。比如dbproxy使用的是libevent。
程序里具体用几个loop、线程池的大小等参数需要根据应用来设定，基本的原则是“阻抗匹配”（解释见下），使得CPU和IO都能高效地运作。所谓阻抗匹配原则：
如果池中线程在执行任务时，密集计算所占的时间比重为 P (0 就能立刻列出用到某服务的客户端地址（Foreign Address列），然后在客户端的机器上用netstat或lsof命令找出是哪个进程发起的连接。TCP短连接和UDP则不具备这一特性。二是通过接收和发送队列的长度也较容易定位网络或程序故障。在正常运行的时候，netstat打印的Recv-Q和Send-Q都应该接近0，或者在0附近摆动。如果Recv-Q保持不变或持续增加，则通常意味着服务进程的处理速度变慢，可能发生了死锁或阻塞。如果Send-Q保持不变或持续增加，有可能是对方服务器太忙、来不及处理，也有可能是网络中间某个路由器或交换机故障造成丢包，甚至对方服务器掉线，这些因素都可能表现为数据发送不出去。通过持续监控Recv-Q和Send-Q就能及早预警性能或可用性故障。以下是服务端线程阻塞造成Recv-Q和客户端Send-Q激增的例子：
view plain copy
$netstat -tn
Proto Recv-Q Send-Q Local Address Foreign
tcp.0.0.10:.0.0.10:#服务端连接
tcp.0.0.10:.0.0.10:#客户端连接
tcp.0.0.10:.0.0.4:
五：多线程服务器的适用场合
如果要在一台多核机器上提供一种服务或执行一个任务，可用的模式有：
a：运行一个单线程的进程；
b：运行一个多线程的进程；
c：运行多个单线程的进程；
d：运行多个多线程的进程；
考虑这样的场景：如果使用速率为50MB/s的数据压缩库，进程创建销毁的开销是800微秒，线程创建销毁的开销是50微秒。如何执行压缩任务？
如果要偶尔压缩1GB的文本文件，预计运行时间是20s，那么起一个进程去做是合理的，因为进程启动和销毁的开销远远小于实际任务的耗时。
如果要经常压缩500kB的文本数据，预计运行时间是10ms，那么每次都起进程 似乎有点浪费了，可以每次单独起一个线程去做。
如果要频繁压缩10kB的文本数据，预计运行时间是200微秒，那么每次起线程似 乎也很浪费，不如直接在当前线程搞定。也可以用一个线程池，每次把压缩任务交给线程池，避免阻塞当前线程（特别要避免阻塞IO线程）。
由此可见，多线程并不是万灵丹(silver bullet)。
1：必须使用单线程的场合
据我所知，有两种场合必须使用单线程：
a：程序可能会fork(2)；
实际编程中，应该保证只有单线程程序能进行fork(2)。多线程程序不是不能调用fork(2)，而是这么做会遇到很多麻烦：
fork一般不能在多线程程序中调用，因为Linux的fork只克隆当前线程的thread of control，不可隆其他线程。fork之后，除了当前线程之外，其他线程都消失了。
这就造成一种危险的局面。其他线程可能正好处于临界区之内，持有了某个锁，而它突然死亡，再也没有机会去解锁了。此时如果子进程试图再对同一个mutex加锁，就会立即死锁。因此，fork之后，子进程就相当于处于signal handler之中（因为不知道调用fork时，父进程中的线程此时正在调用什么函数，这和信号发生时的场景一样），你不能调用线程安全的函数（除非它是可重入的），而只能调用异步信号安全的函数。比如，fork之后，子进程不能调用：
malloc，因为malloc在访问全局状态时几乎肯定会加锁；
任何可能分配或释放内存的函数，比如snprintf；
任何Pthreads函数；
printf系列函数，因为其他线程可能恰好持有stdout/stderr的锁；
除了man 7 signal中明确列出的信号安全函数之外的任何函数。
因此，多线程中调用fork，唯一安全的做法是fork之后，立即调用exec执行另一个程序，彻底隔断子进程与父进程的联系。
在多线程环境中调用fork，产生子进程后。子进程内部只存在一个线程，也就是父进程中调用fork的线程的副本。
使用fork创建子进程时，子进程通过继承整个地址空间的副本，也从父进程那里继承了所有互斥量、读写锁和条件变量的状态。如果父进程中的某个线程占有锁，则子进程同样占有这些锁。问题是子进程并不包含占有锁的线程的副本，所以子进程没有办法知道它占有了哪些锁，并且需要释放哪些锁。
尽管Pthread提供了pthread_atfork函数试图绕过这样的问题，但是这回使得代码变得混乱。因此《Programming With Posix Threads》一书的作者说：”Avoid using fork in threaded code except where the child process will immediately exec a new program.”。
b：限制程序的CPU占用率；
这个很容易理解，比如在一个8核的服务器上，一个单线程程序即便发生busy-wait，占满1个core，其CPU使用率也只有12.5%，在这种最坏的情况下，系统还是有87.5%的计算资源可供其他服务进程使用。
linux socket多线程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于linux socket多线程,「探索 Linux 网络编程：socket 多线程」,socket编程在windows和linux下的区别,如何看懂《Linux多线程服务端编程的信息别忘了在本站进行查找喔。
