第一步: 配置存储池
Virsh命令行工具是一款管理virsh客户域的用户界面。virsh程序能在命令行中运行所给的命令以及它的参数。
本节中，我们要用它给我们的KVM环境创建存储池。想知道关于这个工具的更多信息，用以下这条命令。
# man virsh
用virsh带pool-define-as的命令来定义新的存储池，你需要指定名字、类型和类型参数。
本例中，我们将名字取为Spool1，类型为目录。默认情况下你可以提供五个参数给该类型：
source-host
source-path
source-dev
source-name
target
对于目录类型，我们需要用最后一个参数“target”来指定存储池的路径，其它参数项我们可以用“-”来填充。
# virsh pool-define-as Spool1 dir - - - - "/mnt/personal-data/SPool1/"
创建新存储池
2. 查看环境中我们所有的存储池，用以下命令。
# virsh pool-list --all
列出所有存储池
3. 现在我们来构造存储池了，用以下命令来构造我们刚才定义的存储池。
# virsh pool-build Spool1
构造存储池
4. 用带pool-start参数的virsh命令来激活并启动我们刚才创建并构造完成的存储池。
# virsh pool-start Spool1
激活存储池
5. 查看环境中存储池的状态，用以下命令。
# virsh pool-list --all
2. linux开机启动会依次加载哪些脚本
1、相关基础知识点x0dx0a 1）redhat的启动方式和执行次序是： x0dx0a加载内核 x0dx0a执行init程序 x0dx0a /etc/rc.d/rc.sysinit # 由init执行的第一个脚本 x0dx0a /etc/rc.d/rc $RUNLEVEL # $RUNLEVEL为缺省的运行模式 x0dx0a /etc/rc.d/rc.local #相应级别服务启动之后、在执行该文件（其实也可以把需要执行的命令写到该文件中）x0dx0a /sbin/mingetty # 等待用户登录 x0dx0ax0dx0a在Redhat中，/etc/rc.d/rc.sysinit主要做在各个运行模式中相同的初始化工作，包括： x0dx0a调入keymap以及系统字体 x0dx0a启动swapping x0dx0a设置主机名 x0dx0a设置NIS域名 x0dx0a检查（fsck）并mount文件系统 x0dx0a打开quota x0dx0a装载声卡模块 x0dx0a设置系统时钟 x0dx0ax0dx0a等等。 x0dx0a /etc/rc.d/rc则根据其参数指定的运行模式(运行级别，你在inittab文件中可以设置)来执行相应目录下的脚本。凡是以Kxx开头的，都以stop为参数来调用；凡是以Sxx开头的，都以start为参数来调用。调用的顺序按xx从小到大来执行。(其中xx是数字、表示的是启动顺序)例如，假设缺省的运行模式是3，/etc/rc.d/rc就会按上述方式调用 /etc/rc.d/rc3.d/下的脚本。 x0dx0ax0dx0a值得一提的是，Redhat中的运行模式2、3、5都把/etc/rc.d/rc.local做为初始化脚本中的最后一个，所以用户可以自己在这个文件中添加一些需要在其他初始化工作之后，登录之前执行的命令。 x0dx0a init在等待/etc/rc.d/rc执行完毕之后（因为在/etc/inittab中/etc/rc.d/rc的 x0dx0a action是wait），将在指定的各个虚拟终端上运行/sbin/mingetty，等待用户的登录。 x0dx0ax0dx0a至此，LINUX的启动结束。x0dx0a 2、init运行级别及指令x0dx0ax0dx0a一、什么是INIT: x0dx0ainit是Linux系统操作中不可缺少的程序之一。 x0dx0a所谓的init进程，它是一个由内核启动的用户级进程。 x0dx0a内核自行启动（已经被载入内存，开始运行，并已初始化所有的设备驱动程序和数据结构等）之后，就通过启动一个用户级程序init的方式，完成引导进程。所以,init始终是第一个进程（其进程编号始终为1）。 x0dx0a内核会在过去曾使用过init的几个地方查找它，它的正确位置（对Linux系统来说）是/sbin/init。如果内核找不到init，它就会试着运行/bin/sh，如果运行失败，系统的启动也会失败。x0dx0a二、运行级别 x0dx0a那么，到底什么是运行级呢？ x0dx0a简单的说，运行级就是操作系统当前正在运行的功能级别。这个级别从1到6 ，具有不同的功能。 x0dx0a不同的运行级定义如下 x0dx0a# 0 - 停机（千万不能把initdefault 设置为0 ） x0dx0a# 1 - 单用户模式 # s init s = init 1x0dx0a# 2 - 多用户，没有 NFS x0dx0a# 3 - 完全多用户模式(标准的运行级) x0dx0a# 4 - 没有用到 x0dx0a# 5 - X11 多用户图形模式（xwindow) x0dx0a# 6 - 重新启动 （千万不要把initdefault 设置为6 ） x0dx0a这些级别在/etc/inittab 文件里指定。这个文件是init 程序寻找的主要文件，最先运行的服务是放在/etc/rc.d 目录下的文件。在大多数的Linux 发行版本中，启动脚本都是位于 /etc/rc.d/init.d中的。这些脚本被用ln 命令连接到 /etc/rc.d/rcn.d 目录。(这里的n 就是运行级0-6) x0dx0a 3）：chkconfig 命令（redhat 操作系统下）x0dx0ax0dx0a不像DOS 或者 Windows，Linux 可以有多种运行级。常见的就是多用户的2,3,4,5 ，很多人知道 5 是运行 X-Windows 的级别，而 0 就x0dx0a是关机了。运行级的改变可以通过 init 命令来切换。例如，假设你要维护系统进入单用户状态，那么，可以使用 init 1 来切换。在 Linux 的运行级的切换过程中，系统会自动寻找对应运行级的目录/etc/rc[0-6].d下的K 和 S 开头的文件，按后面的数字顺序，执行这x0dx0a些脚本。对这些脚本的维护，是很繁琐的一件事情，Linux 提供了chkconfig 命令用来更新和查询不同运行级上的系统服务。 x0dx0ax0dx0a语法为： x0dx0a chkconfig --list [name] x0dx0a chkconfig --add name x0dx0a chkconfig --del name x0dx0a chkconfig [--level levels] name x0dx0a chkconfig [--level levels] name x0dx0a chkconfig 有五项功能：添加服务，删除服务，列表服务，改变启动信息以及检查特定服务的启动状态。 x0dx0a chkconfig 没有参数运行时，显示用法。如果加上服务名，那么就检查这个服务是否在当前运行级启动。如果是，返回 true，否则返回false。 --level 选项可以指定要查看的运行级而不一定是当前运行级。 x0dx0ax0dx0a如果在服务名后面指定了on，off 或者 reset，那么 chkconfig 会改变指定服务的启动信息。on 和 off 分别指服务在改变运行级时的启动和停止。reset 指初始化服务信息，无论有问题的初始化脚本指定了什么。 x0dx0ax0dx0a对于 on 和 off 开关，系统默认只对运行级 3，4， 5有效，但是 reset 可以对所有运行级有效。指定 --level 选项时，可以选择特定的运行级。 x0dx0a x0dx0a需要说明的是，对于每个运行级，只能有一个启动脚本或者停止脚本。当切换运行级时，init 不会重新启动已经启动的服务，也不会再次去停止已经停止的服务。 x0dx0ax0dx0a选项介绍： x0dx0a --level levels x0dx0ax0dx0a指定运行级，由数字 0 到 7 构成的字符串，如： x0dx0a --level 35 表示指定运行级3 和5。 x0dx0ax0dx0a要在运行级别3、4、5中停运 nfs 服务，使用下面的命令：chkconfig --level 345 nfs off x0dx0a --add name x0dx0ax0dx0a这个选项增加一项新的服务，chkconfig 确保每个运行级有一项启动(S) 或者 杀死(K) 入口。如有缺少，则会从缺省的init 脚本自动x0dx0a建立。 x0dx0a --del name x0dx0ax0dx0a用来删除服务，并把相关符号连接从 /etc/rc[0-6].d 删除。 x0dx0a --list name x0dx0ax0dx0a列表，如果指定了name 那么只是显示指定的服务名，否则，列出全部服务在不同运行级的状态。 x0dx0ax0dx0a运行级文件 x0dx0ax0dx0a每个被chkconfig 管理的服务需要在对应的init.d 下的脚本加上两行或者更多行的注释。 x0dx0ax0dx0a第一行告诉 chkconfig 缺省启动的运行级以及启动和停止的优先级。如果某服务缺省不在任何运行级启动，那么使用 - 代替运行级。 x0dx0ax0dx0a第二行对服务进行描述，可以用 跨行注释。 x0dx0ax0dx0a例如，random.init 包含三行： x0dx0a # chkconfig: 2345 20 80 x0dx0a # description: Saves and restores system entropy pool for x0dx0a # higher quality random number generation. x0dx0ax0dx0a表明 random 脚本应该在运行级 2, 3, 4, 5 启动，启动优先权为20，停止优先权为 80。 x0dx0ax0dx0a好了，介绍就到这里了，去看看自己目录下的/etc/rc.d/init.d 下的脚本吧。 x0dx0ax0dx0a设置自启动服务:chkconfig --level 345 nfs on x0dx0a2. 实例介绍：x0dx0a 1、在linux下安装了apache 服务（通过下载二进制文件经济编译安装、而非rpm包）、apache 服务启动命令： /server/apache/bin/apachectl start 。让apache服务运行在运行级别3下面。x0dx0a命令如下： x0dx0a 1）touch /etc/rc.d/init.d/apachex0dx0a vi /etc/rc.d/init.d/apachex0dx0a chown -R root /etc/rc.d/init.d/apachex0dx0a chmod 700 /etc/rc.d/init.d/apachex0dx0a ln -s /etc/rc.d/init.d/apache /etc/rc.d/rc3.d/S60apache #S 是start的简写、代表启动、K是kill的简写、代表关闭。60数字x0dx0a代表启动的顺序。（对于iptv系统而言、许多服务都是建立在数据库启动的前提下才能够正常启动的、可以通过该数字就行调整脚本的启动顺序）） x0dx0a apache的内容：x0dx0a #!/bin/bashx0dx0a #Start httpd servicex0dx0a /server/apache/bin/apachectl startx0dx0ax0dx0a至此 apache服务就可以在运行级别3下 随机自动启动了。（可以结合chkconfig 对启动服务进行相应的调整）。x0dx0a由于相关变量定义不同, 所以以下启动顺序仅供参考x0dx0a在Redhat Redflag centos fc linux系统里面脚本的启动x0dx0a先后：x0dx0a第一步：通过/boot/vm进行启动 vmlinuzx0dx0a第二步：init /etc/inittabx0dx0a第三步：启动相应的脚本，并且打开终端x0dx0arc.sysinitx0dx0arc.d(里面的脚本）x0dx0arc.localx0dx0a第四步：启动login登录界面 loginx0dx0a第五步:在用户登录的时候执行sh脚本的顺序：每次登录的时候都会完全执行的x0dx0a/etc/profile.d/filex0dx0a/etc/profilex0dx0a/etc/bashrcx0dx0a/root/.bashrcx0dx0a/root/.bash_profilex0dx0a编者注：x0dx0aNtsysv命令也可以实现根据不同运行级别启动不同的服务，但是一定要注意，使用ntsysv命令，默认采用图形的方式管理服务的启动，但是在这种情况下设置的服务，只对当前的运行级别有效果！因此，建议最好还是使用 chkconfig 来进行服务的管理。
3. 关于linux下多线程编程
pthread_join 线程停止等待函数没有调用
pthread_create 线程生成后，没有等子线程停止，主线程就先停止了。
主线程停止后，整个程序停止，子线程在没有printf的时候就被结束了。
结论：不是你没有看到结果，而是在子线程printf("..................\n");之前整个程序就已经停止了。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#define FALSE -1
#define TRUE 0
void *shuchu( void *my )
{
int j;
printf("..................\n");
}
int main()
{
int i = 0;
int rc = 0;
int ret1;
pthread_t p_thread1;
if(0!=(ret1 = pthread_create(&p_thread1, NULL, shuchu, NULL)))printf("sfdfsdfi\n");
printf("[%d]\n",p_thread1);
pthread_join(p_thread1, NULL);
return TRUE;
}
4. 配置Linux的时钟同步
Ubuntu系统默认的时钟同步服务器是ntp.ubuntu.com，Debian则是0.debian.pool.ntp.org等， 各Linux发行版都有自己的NTP官方服务器。身在中国，使用这些都会有高延迟，但对时钟同步这件事来说影响不大。
在某些环境下，比如公司内网、云上子网等，是与互联网隔绝的。这时要想做时钟同步，就只能自己配置了。
本文介绍如何自己配置时钟同步，不介绍如何自建NTP服务器。
一般timesync是预装的。如果没有，可以使用以下命令手动安装。
sudo apt install systemd-timesyncd 它和ntp是冲突的，二者只能安装一个。
修改/etc/systemd/timesyncd.conf，把NTP设为华为内绿区可达的NTP服务器。
修改完成后，需要restart后这个配置才生效。
如果以上systemd-timesyncd.service因为什么原因而不存在，则可通过以下命令修复：
一般查看日期与时间是使用date。使用timedatectl可以查看到更多时钟同步相关信息。
以下给出一些阿里云的NTP列表，可以通过ping择优使用。
以上就是 良许教程网 为各位朋友分享的配置Linux的时钟同步。
最后，最近很多小伙伴找我要 Linux学习路线图 ，于是我根据自己的经验，利用业余时间熬夜肝了一个月，整理了一份电子书。无论你是面试还是自我提升，相信都会对你有帮助！目录如下：
免费送给大家，只求大家金指给我点个赞！
电子书 | Linux开发学习路线图
也希望有小伙伴能加入我，把这份电子书做得更完美！
推荐阅读：
5. 请教LINUX怎么配置主备DHCP服务器
第一节：安装软件包
用命令行安装软件包（在第5张光盘上）或直接“添加删除程序--网络服务器”，只要安装dhcp-3.0.1-59.EL4.i386.rpm：
第二节：配置DHCP双机负载均衡
目前DHCP-Failover（虽然叫failover，但实际上是双机同时在工作）仅支持最多两个节点。配置文件和单机配置一样，依然是/etc/dhcpd.conf；但出于方便管理的目的，在部署时，我们把地址池的配置放在/etc/dhcpd.master文件中，然后在/etc/dhcpd.conf中调用。
主节点的/etc/dhcpd.conf：
authoritative;
ddns-update-style interim;
ignore client-updates;
one-lease-per-client true;
failover peer "dhcp" {
primary;
address 10.14.0.9;
port 520;
peer address 10.14.0.13;
peer port 519;
max-response-delay 60;
max-unacked-updates 10;
mclt 600;
split 128;
load balance max seconds 3;
}
include "/etc/dhcpd.master";
次节点的/etc/dhcpd.conf：
authoritative;
ddns-update-style interim;
ignore client-updates;
one-lease-per-client true;
failover peer "dhcp" {
secondary;
address 10.14.0.13;
port 519;
peer address 10.14.0.9;
peer port 520;
max-response-delay 60;
max-unacked-updates 10;
}
include "/etc/dhcpd.master";
【注意】
1、两台dhcp server的时间必须同步，可用ntp
2、Dhcp Failover的互相监听地址可以采用专用网卡互相直连做心跳的方式，甚至心跳卡可以考虑双网卡绑定！从而使监听和网络数据流分开，即使网络中断亦不会因此导致dhcp双机中断，如下所示：
这种时候Failover专用接口所在网段，可在地址池中定义一个空池，不做任何地址分配操作：
subnet x.x.x.x netmask 255.255.255.248 {
}
本文列出的配置是采用心跳和数据网卡混用的方式。
/etc/dhcpd.conf
主控服务器
authoritative;
ddns-update-style interim;
ignore client-updates;
one-lease-per-client true;
failover peer "dhcp" {
primary;
address 10.14.0.9;
port 520;
peer address 10.14.0.13;
peer port 519;
max-response-delay 60;
max-unacked-updates 20;
mclt 3600;
split 128;
load balance max seconds 3;
}
include "/etc/dhcpd.master";
说明
说明这是正式（官方）服务器，而非测试用
动态DNS的更新方式，有3种1
不允许客户机更新DNS记录
每一个客户机对应一个租约信息（文件）2
指定本机所属failover域的识别码为dhcp
指定本机为主控服务器
指定本机的监听地址
指定本机的监听端口
对端的监听地址
对端的监听端口
最大无响应时间 60秒，如果地址池很多这个时间可加大3
在得到对端响应之前，最多连续发送20个消息
双机联系中断时所分配的地址的租约时间，3600秒
负载分担比例，取值0－256，128为平均分担负载
地址池文件
【注1】这个style参数必须是interim(推荐)、ad-hoc或者none
【注2】假如这个标志配置成true（enabled），当一个客户端发送一个DHCPREQUEST信息来租用租约时，服务器会自动释放任何这个客户的任何其他租约。服务器假定当一个客户端发送DHCPREQUEST信息时，他已忘记任何他没有在 DHCPREQUEST中提到的租约，例如，客户端只是个简单的网络接口，不能记住原来拥有而现在不用的租约。这些假定都是没有确保，而且不可证实的，因此小心使用这个语句。
【注3】如果这个值不够大，会发生地址池还未同步结束，就产生连接中断现象。在拥有近1万个地址池时，这个值被设为180。
/etc/dhcpd.master
两个节点的地址池配置必须保持完全一致。
option domain-name-servers 10.14.0.9,10.14.0.13;
default-lease-time 21600;
max-lease-time 43200;
subnet 10.14.0.8 netmask 255.255.255.248 {
option routers 10.14.0.14;
pool {
failover peer "dhcp";
range 10.14.0.11 10.14.0.12;
deny dynamic bootp clients;
}
}
#shuniu
subnet 10.0.0.0 netmask 255.255.224.0 {
option routers 10.0.31.254;
pool {
failover peer "dhcp";
range 10.0.0.1 10.0.31.250;
deny dynamic bootp clients;
}
}
......
有多少个网段就有多少个地址池，一个个配置下去。
域名服务器
默认租约时间（6小时）
最大租约时间
定义子网/掩码
定义子网的网关
地址池
属于名为 dhcp 的failover组
地址范围，可多条range
拒绝bootp客户端
第三节：管理操作
在两个节点依次启动dhcp服务，先主后备。
# service dhcpd start
配置自动启动
# chkconfig dhcpd on
验证
# netstat -anutp | grep dhcpd
udp 0 0 0.0.0.0:67 0.0.0.0:* 6581/dhcpd
查看地址租借信息
# cat /var/lib/dhcp/dhcpd.leases
3.1、租约文件
dhcpd每次都会把所有的租借信息写到/var/lib/dhcpd.leases文件中，上一次的租借文件被改名成dhcpd.leases~
3.2、地址池同步
每次重启DHCP服务时，双机都会自动执行地址池同步操作。
在次服务器上：
# service dhcpd congrestart
3.3、查看日志信息
凡是有任何和DHCP服务器的地址分配有关的故障，都可以通过查看日志文件分析出原因并得以处理。
# tail -f /var/log/messages
其他的故障绝大部分是由于作为中转的DHCP-RELAY设备配置有问题导致。
3.4、简要故障
1、某台服务器无法为某个网段的客户机提供地址租借服务
有时会由于某种原因导致双机地址池无法合理分配，比如主服务器掌控了某个地址池的所有地址，这时需要先停止两个节点的dhcp服务，删除两个节点的地址租约文件，然后依次重启服务。
2、无法形成双机
请注意两个节点的时间是否一致，如果时间差距太大，比如2分钟，两台dhcp服务器将无法形成集群。可通过配置ntp保持两个节点的时间同步。
6. 如何看懂《Linux多线程服务端编程
一：进程和线程
每个进程有自己独立的地址空间。“在同一个进程”还是“不在同一个进程”是系统功能划分的重要决策点。《Erlang程序设计》[ERL]把进程比喻为人：
每个人有自己的记忆（内存），人与人通过谈话（消息传递）来交流，谈话既可以是面谈（同一台服务器），也可以在电话里谈（不同的服务器，有网络通信）。面谈和电话谈的区别在于，面谈可以立即知道对方是否死了（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）和事件回调的方式实现业务逻辑：
[cpp] view plain
//代码仅为示意，没有完整考虑各种情况
while(!done)
{
int timeout_ms = max(1000, getNextTimedCallback());
int retval = poll(fds, nfds, timeout_ms);
if (retval<0){
处理错误，回调用户的error handler
}else{
处理到期的timers,回调用户的timer handler
if(retval>0){
处理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实现的任务队列：
[cpp] view plain
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 < N; ++i)
{
create_thread(&workerThread); //启动线程
}
//向任务队列中追加任务
Foo foo; //Foo有calc()成员函数
boost::function 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模式的网络库来支撑，muo正是这样的网络库。比如dbproxy使用的是libevent。
程序里具体用几个loop、线程池的大小等参数需要根据应用来设定，基本的原则是“阻抗匹配”（解释见下），使得CPU和IO都能高效地运作。所谓阻抗匹配原则：
如果池中线程在执行任务时，密集计算所占的时间比重为 P (0 < P <= 1)，而系统一共有 C 个 CPU，为了让这 C 个 CPU 跑满而又不过载，线程池大小的经验公式 T = C/P。（T 是个 hint，考虑到 P 值的估计不是很准确，T 的最佳值可以上下浮动 50%）
以后我再讲这个经验公式是怎么来的，先验证边界条件的正确性。
假设 C = 8，P = 1.0，线程池的任务完全是密集计算，那么T = 8。只要 8 个活动线程就能让 8 个 CPU 饱和，再多也没用，因为 CPU 资源已经耗光了。
假设 C = 8，P = 0.5，线程池的任务有一半是计算，有一半等在 IO 上，那么T = 16。考虑操作系统能灵活合理地调度 sleeping/writing/running 线程，那么大概 16 个“50%繁忙的线程”能让 8 个 CPU 忙个不停。启动更多的线程并不能提高吞吐量，反而因为增加上下文切换的开销而降低性能。
如果 P < 0.2，这个公式就不适用了，T 可以取一个固定值，比如 5*C。
另外，公式里的 C 不一定是 CPU 总数，可以是“分配给这项任务的 CPU 数目”，比如在 8 核机器上分出 4 个核来做一项任务，那么 C=4。
四：进程间通信只用TCP
Linux下进程间通信的方式有：匿名管道(pipe)、具名管道(FIFO)、POSIX消息队列、共享内存、信号(signals)，以及Socket。同步原语有互斥器(mutex)、条件变量(condition variable)、读写锁(reader-writer lock)、文件锁(record locking)、信号量(semaphore)等等。
进程间通信我首选Sockets（主要指TCP，我没有用过UDP，也不考虑Unix domain协议）。其好处在于：
可以跨主机，具有伸缩性。反正都是多进程了，如果一台机器的处理能力不够，很自然地就能用多台机器来处理。把进程分散到同一局域网的多台机器上，程序改改host:port配置就能继续用；
TCP sockets和pipe都是操作文件描述符，用来收发字节流，都可以read/write/fcntl/select/poll等。不同的是，TCP是双向的，Linux的pipe是单向的，进程间双向通信还得开两个文件描述符，不方便；而且进程要有父子关系才能用pipe，这些都限制了pipe的使用；
TCP port由一个进程独占，且进程退出时操作系统会自动回收文件描述符。因此即使程序意外退出，也不会给系统留下垃圾，程序重启之后能比较容易地恢复，而不需要重启操作系统（用跨进程的mutex就有这个风险）；而且，port是独占的，可以防止程序重复启动，后面那个进程抢不到port，自然就没法初始化了，避免造成意料之外的结果；
与其他IPC相比，TCP协议的一个天生的好处是“可记录、可重现”。tcpmp和Wireshark是解决两个进程间协议和状态争端的好帮手，也是性能（吞吐量、延迟）分析的利器。我们可以借此编写分布式程序的自动化回归测试。也可以用tcp之类的工具进行压力测试。TCP还能跨语言，服务端和客户端不必使用同一种语言。
分布式系统的软件设计和功能划分一般应该以“进程”为单位。从宏观上看，一个分布式系统是由运行在多台机器上的多个进程组成的，进程之间采用TCP长连接通信。
使用TCP长连接的好处有两点：一是容易定位分布式系统中的服务之间的依赖关系。只要在机器上运行netstat -tpna|grep 就能立刻列出用到某服务的客户端地址（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激增的例子：
[cpp] view plain
$netstat -tn
Proto Recv-Q Send-Q Local Address Foreign
tcp 78393 0 10.0.0.10:2000 10.0.0.10:39748 #服务端连接
tcp 0 132608 10.0.0.10:39748 10.0.0.10:2000 #客户端连接
tcp 0 52 10.0.0.10:22 10.0.0.4:55572
五：多线程服务器的适用场合
如果要在一台多核机器上提供一种服务或执行一个任务，可用的模式有：
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%的计算资源可供其他服务进程使用。
因此对于一些辅助性的程序，如果它必须和主要服务进程运行在同一台机器的话，那么做成单线程的能避免过分抢夺系统的计算资源。
7. LINUX时间同步脚本或命令！
Linux
下
时间同步命令：
ntpdate
linux系统下默认安装了ntp服务，手动进行ntp同步如下
$ntpdate
ntp1.nl.net
当然，也可以指定其它的ntp服务器
公网上的NTP服务器列表：
http://www.pool.ntp.org/zone/asia
根据这个列表，中国有个服务器：cn.pool.ntp.org
用
ntpdate
命令来同步时间：
ntpdate
cn.pool.ntp.org
可以将这个命令加到
cron
table
里面，每天执行。
8. 如何使两台linux服务器时间同步
Linux自带了ntp服务 -- /etc/init.d/ntpd，这个服务不仅可以设置让本机和某台/某些机器做时间同步，他本身还可以扮演一个timeserver的角色，让其他机器和他同步时间。
配置文件就是/etc/ntp.conf。
为了测试，设置让node2 -- 192.168.1.102和node1 -- 192.168.1.101做时间同步。
第一步，
node1做time server，node1本身不和其他机器时间同步，就是取本地时间。
所以，先把node1机器的时间调准了：
[root@node1 ~]date -s 08/03/2011
[root@node1 ~]date -s11:12:00
[root@node1 ~]clock -w
[root@node1 ~]hwclock --systohc
后两个命令是把设置的时间写到硬件时间中去（也就是CMOS里面的时间）。
第二步，
然后将node1配置成一个time server，修改/etc/ntp.conf，
[root@node1 ~]vi /etc/ntp.conf
其他的配置不怎么需要改，只需要关注restrict的配置：
1. 注释掉原来的restrict default ignore这一行，这一行本身是不响应任何的ntp更新请求，其实也就是禁用了本机的ntp server的功能，所以需要注释掉。
2. 加入：restrict 192.168.1.0 mask 255.255.255.0 -- 让192.168.1.0/24网段上的机器能和本机做时间同步
3. 这样就可以了，记得下面的：
server 127.127.1.0 # local clock
fudge 127.127.1.0 stratum 10
这两行需要，这是让本机的ntpd和本地硬件时间同步。
当然，我们也可以添加server xxx.xxx.xxx.xxx，让他和其他的time server时间同步。
4. /etc/init.d/ntpd restart
5. chkconfig ntpd on
6. 修改iptables配置，将tcp和udp 123端口开放，这是ntp需要的端口，在/etc/services中可以查到这个端口。
第三步，
这样node1就成为一台time server了，现在我们配置node2这台机器，也是修改/etc/ntp.conf ，
[root@node2 ~]vi /etc/ntp.conf
1. restrict default ignore这行保留为注释状态，因为sales不需要做time server
2. 注释掉server 127.127.1.0, fudge 127.127.1.0 stratum 10这两行，因为这台机器不需要和本地硬件时钟同步了。
3. 加入server 192.168.1.101这行，和node1机器同步。
这样就OK了。看看时间，已经和node1同步了。往后默认配置好像是5分钟和time server同步一次。ntpdate命令是显式的和某台机器做时间同步，以前将ntpdate放到crontab中定期同步也是可以的，但是既然ntpd本身就可以做这个时间
第四步，将ntpdate放到crontab中定期步也是可以的
[root@node2 ~]#vi ntpupdate.sh
/usr/sbin/ntpdate 192.168.1.101
[root@node2 ~]#chmod 755 ntpupdate.sh
[root@node2 ~]#crontab -e
*/1 * * * * /root/ntpupdate.sh
[root@node2 ~]#/etc/init.d/crond restart