一直不明白“异步”与“同步”问题，求指教

测试昵称666 2011-08-03 05:31:18
一直不明白“异步”与“同步”问题，求指教。

在汤子赢《计算机操作系统》的第二章 进程同步 P48面看到这么一句话：
生产者与消费者问题：
“尽管所有的生产者进程和消费者进程都是以异步方式运行的，但他们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品的缓冲区投放产品”

求牛人讲解下同步和异步以及其关系，和上面这句话的意思，谢谢了。
...全文
536 32 打赏 收藏 转发到动态 举报
写回复
用AI写文章
32 条回复
切换为时间正序
请发表友善的回复…
发表回复
Saleayas 2011-12-21
  • 打赏
  • 举报
 回复
[Quote=引用 9 楼 babilife 的回复:]

同步几乎等于阻塞！
比如一个花痴在女孩子家楼下翘盼，非要见到芳容才肯离开，结果未知！
异步几乎等于非阻塞
这花痴头天没得手，第二天就改用写信的方式投递到了女子家的邮箱里，然后回去实施第二部计划！如送花等
[/Quote]

但是需要等到 她 同意才 KISS。这就是异步时候的同步。
chenkai11111 2011-12-21
  • 打赏
  • 举报
 回复
都是牛人呀！
张小小Angela 2011-08-04
  • 打赏
  • 举报
 回复
[Quote=引用楼主 wtq493841534 的回复:]
一直不明白“异步”与“同步”问题，求指教。

在汤子赢《计算机操作系统》的第二章 进程同步 P48面看到这么一句话：
生产者与消费者问题：
“尽管所有的生产者进程和消费者进程都是以异步方式运行的，但他们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品的缓冲区投放产品”

求牛人讲解下同步和异步以及其关系，和上面这句话的意思，谢谢了。
[/Quote]
异步是指 消费者和生产者的活动是相互独立的，两者的速度可以不一样，但因为缓冲区的原因两者又必须保持同步，因为不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品的缓冲区投放产品。
好比说甲乙两个人同时一起出发去某地， 两者可以采用不同的方式，前进的速度也不同，这个是异步。但最后快的一方必须要等慢的一方，这个是同步，因为是要到某地。这个就是我的理解，仅作参考
Joe-xXx 2011-08-04
  • 打赏
  • 举报
 回复
生产者和消费者的活动是不互相干扰的，这就是一种异步；
而消费者要得到消费品，必须等待生产者生产出来，而生产者要得到利益或汇报，必须等待要消费者购买之后。
在等待时刻就是一种同步。
赵4老师 2011-08-04
  • 打赏
  • 举报
 回复
“等我吃完饭你再打电话给我好吗？”——同步
“我吃饭时你也可以打电话给我呀。”——异步
skye_ld 2011-08-04
  • 打赏
  • 举报
 回复
。。。。简单的说

同步 就是步子一样
异步 就是步子不一样

明白了么？这个解释可以概括以上所有的解释
phoeni_xin 2011-08-04
  • 打赏
  • 举报
 回复
好多人。。。学习。
blackkettle 2011-08-04
  • 打赏
  • 举报
 回复
举个例子。。。
同步就是你妈妈喊你回家吃饭，然后她会进入阻塞状态不会干别的事等着直到你回到家准备吃饭。。
异步就是你妈妈喊你回家吃饭，说完可以立马干别的事去了，你愿意什么时候回家吃饭就什么时候回家吃饭，对你妈妈的活动不造成影响。。。


这个不错!
寒沙胜雪 2011-08-04
  • 打赏
  • 举报
 回复
进程同步与互斥是考试的重点吧。也是编程的重点。
进程的同步是间接制约关系，互斥是直接制约关系。
你写写多线程编程吧。
nightkids_008 2011-08-04
  • 打赏
  • 举报
 回复
[Quote=引用 9 楼 babilife 的回复:]
同步几乎等于阻塞！
比如一个花痴在女孩子家楼下翘盼，非要见到芳容才肯离开，结果未知！
异步几乎等于非阻塞
这花痴头天没得手，第二天就改用写信的方式投递到了女子家的邮箱里，然后回去实施第二部计划！如送花等
[/Quote]
你好YD！什么都能类比到这方面，甘拜下风！
lml926it 2011-08-04
  • 打赏
  • 举报
 回复
异步就是可以同时做多件事，同步就是必须一件一件的做；
都说比如的话我也来说，比如说一个人走路，如果他只是在走路的话就说同步，
如果他在走路的时候还听着音乐的话就是异步了
jiangfaqun 2011-08-04
  • 打赏
  • 举报
 回复
顶5楼！~~~~~~~~~~~~解析很简单，效果很明显。
showjim 2011-08-04
  • 打赏
  • 举报
 回复
同步就是需要等待，比如火车有时候会停下来等别的车走了再走
异步就是各走各的，不相关
turing-complete 2011-08-04
  • 打赏
  • 举报
 回复
其实，本身很简单，难就难在了，计算机术语的乱用。“同步”在计算机中有两种解释，一种就是我们最好理解的，也就是生活用语的同步，即同时进行。

第二种在计算机中出现的概率比第一种要大，意思是“对资源的互斥占用”，这个地方为什么当初起名同步，我实在是理解不了，也许英文的synchronize想表达一个“协调”的意思，而我们给直译过来了，造成的很多人对这个术语的误解。
pathuang68 2011-08-03
  • 打赏
  • 举报
 回复
[Quote=引用 9 楼 babilife 的回复:]

同步几乎等于阻塞！
比如一个花痴在女孩子家楼下翘盼，非要见到芳容才肯离开，结果未知！
异步几乎等于非阻塞
这花痴头天没得手，第二天就改用写信的方式投递到了女子家的邮箱里，然后回去实施第二部计划！如送花等
[/Quote]

同步就是阻塞，异步就是非阻塞。
日晞Pisces 2011-08-03
  • 打赏
  • 举报
 回复
同步就是直接制约关系，比如你要喝开水，就要先把水烧开，再喝。（水烧开与喝开水属于直接制约关系）
异步就是间接制约关系，比如你要喝开水，同时你就不能和果汁或者饮料。（喝开水与喝果汁属于间接制约关系）
品茶 2011-08-03
  • 打赏
  • 举报
 回复
10L我的发言有欠考虑

更正如下：
如果不对“进”和“销”同步 那么
当厂家都认为商店不能进货的时候 说不定商店已经卖出了一些手机 其实还是可以进货的
当消费者认为商店没货的时候 说不定厂家又生产了一些手机
这样引发的问题就是容易出现供货断层

所以这两种不同行为也应该同步
品茶 2011-08-03
  • 打赏
  • 举报
 回复
理论上 生产和消费是不同的行为 应该异步
补充说明一下这句

假设有M家手机厂商生产手机 这些厂商都是商店O的供货商 他们生产的手机可以是同一种也可以不同 这要看O是专卖店还是百货店 不过这不要紧 知道总手机数量a就可以了
这些厂家行为相同 定义M个线程A[0] A[1]....A[M]
假设O可以接收1000部手机 如果不对这M个线程同步 那么可能会这样：
当O已经有999部手机的时候 M家厂家都认为还可以再生产一部 这样就多出了M-1部手机 O收不了 有M-1家厂家就浪费了资源
所以设计的时候要同步

说完“进”和“存”再说说“销”
假设O有N名营业员 嗯 应该定义N个线程B[0] B[1]...B[N] 如果不同步 那么可能会出现这种情况
当还剩下1部手机时 所有营业员都认为还可以卖1部.........

所以原则上 同种行为最好同步


maquan 2011-08-03
  • 打赏
  • 举报
 回复
[Quote=引用楼主 wtq493841534 的回复:]
一直不明白“异步”与“同步”问题，求指教。
在汤子赢《计算机操作系统》的第二章 进程同步 P48面看到这么一句话：
生产者与消费者问题：
“尽管所有的生产者进程和消费者进程都是以异步方式运行的，但他们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品的缓冲区投放产品”
求牛人讲解下同步和异步以及其关系，和上面这句话的意思，谢谢了。
[/Quote]
在这里，“异步”和“同步”并不是一对反义词。

“异步”是形容词，指两者的行为是各做各的，就像两个独立的线程，各自执行自己的指令序列；

“同步”是动词，是说它们各自的行为在访问某项公共资源的时候必须按要求互相规避，就像两个线程访问一个共用的全局变量，一个要访问的时候，必须等到另一个不在访问的时候才可以。这个“等”的动作，就是“同步”。


————————————————————————————————
基于CSDN论坛提供的插件扩展功能，自己做了个签名档工具，分享给大家，欢迎技术交流 :)
就想叫yoko 2011-08-03
  • 打赏
  • 举报
 回复
你误解我的意思了
你这里引用的
异步 指的是 不做外加处理，生产者线程（或进程） 与 消费者线程（或进程）执行的顺序、快慢是不确定的， 比如可能生产者生成了2个产品， 消费者才消费1个， 也可能生产者生成了1个产品， 消费者却消费2个， 正是如此， 才需要同步， 同步就是控制生产者、消费者的执行顺序。
“即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品的缓冲区投放产品”
指的是你同步所要达到的效果
[Quote=引用 12 楼 wtq493841534 的回复:]

引用 2 楼 q191201771 的回复:
这句话里面的同步 异步的意思是

生产者 消费者 就像 两个 跑步者

异步就是它们谁跑得快 跑到哪是不确定的

同步就是你控制它们


我可不可以理解为：
在未出现缓冲区满或空的情况下，是异步执行
在缓冲区满或空的情况下，是同步执行
[/Quote]
加载更多回复（12）
一个进程池的服务器程序
一个进程池的服务器程序 下面做了非常简单的http服务器，该服务器只能接收Get请求。 流程大概如下： 1，父进程listen，创建pipe（下面所有父子进程之间的通信都用该pipe） 2，父进程预fork n个子进程 3，各个子进程accept(listenfd)，即所有子进程竞争accept请求。由于listenfd是在fork之前就有的，所以所有子进程都可以访问到，不需用到“进程间文件描述符传递”问题； 4，子进程每accept到一个请求都告诉父进程，父进程把请求数加1；子进程没完成一个请求，父进程把请求数减1；当父进程发现请求数 >= 子进程数时，父进程创建新的子进程，并把子进程数加1（当然子进程数有个预先上限）；当父进程发现子进程数大于请求数加1时，父进程杀死多余的子进程。 总的来说，思想是让子进程accept并处理请求，父进程通过子进程发来的信息控制请求数与子进程数之间的关系。 代码如下： 代码如下： #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define PRECHILD 5 #define MAXCHILD 50 #define BUFSIZE 4096 #define PIDPATH "pid" #define head503 "HTTP/1.1 503 Service unavailable\r\n" #define head404 "HTTP/1.1 404 Not Found\r\n" #define head200 "HTTP/1.1 200 0K\n\rContent—Type: text/html\n\rContent—Length: " int len503, len404, len200; int fd1[2], fd2[2]; typedef struct { pid_t pid; char status; // 'n' means new request; 'f' means finish the request } REPORT; void answer(int listenfd) { int connfd; char buf[BUFSIZE]; int count; int pid = getpid(); struct sockaddr_in cliaddr; int size = sizeof(cliaddr); char comm; REPORT rep; rep.pid = pid; while (1) { connfd = accept(listenfd, (struct sockaddr *)&cliaddr,(socklen_t *)&size ); //子进程accept请求 rep.status = 'n'; if (write(fd1[1], &rep, sizeof(rep)) < 0) { //通知父进程已经accept了请求 perror("write pipe new failed"); exit(-1); } count = read(connfd, buf, BUFSIZE); char req[10]; char filepath[256]; sscanf(buf, "%s%s", req, filepath + 1); filepath[0] = '.'; if (strcmp("GET", req) != 0) {//503 write(connfd, head503, len503); //goto err_out; close(connfd); exit(-1); } char content[BUFSIZE]; struct stat stbuf; if (lstat(filepath, &stbuf) != 0) { int err = errno; if (err == ENOENT) {//404 write(connfd, head404, len404); } close(connfd); exit(-1); } count = write(connfd, head200, len200); u_int filesize = stbuf.st_size; sprintf(content, "%u\n\r\n\r", filesize); count = write(connfd, content, strlen(content)); FILE *fp = fopen(filepath, "r"); if (fp == NULL) { printf("open file %s failed\n", filepath); close(connfd); exit(-1); } while((count = fread(content, 1, sizeof(content), fp)) > 0) { //printf("%s", content); if (write(connfd, content, count) != count) { printf("write failed\n"); } } fclose(fp); close(connfd); rep.status = 'f'; if (write(fd1[1], &rep, sizeof(rep)) < 0) {//告诉父进程自己处理完了请求 perror("write pipe finish failed"); exit(-1); } if (read(fd2[0], &comm, 1) < 1) {//等待来自父进程的命令 perror("read pipe failed"); exit(-1); } //printf("[%d] reve %c from pa\n", pid, comm); if (comm == 'e') { //收到exit命令 printf("[%d] exit\n", pid); exit(-1); } else if (comm == 'c') { //收到继续accept的命令 printf("[%d] continue\n", pid); } else { printf("[%d] comm : %c illeagle\n", pid, comm); } } } void usage() { printf("Usage: http-serv port\n"); } int write_pid() { int fd; if ((fd = open(PIDPATH, O_WRONLY | O_TRUNC | O_CREAT, S_IWUSR)) < 0){ perror("open pidfile faild"); return -1; } struct flock lock; lock.l_type = F_WRLCK; lock.l_start = 0; lock.l_whence = SEEK_SET; lock.l_len = 0; if (fcntl(fd, F_SETLK, &lock) == -1) { int err = errno; perror("fcntl faild"); if (err == EAGAIN) { printf("Another http-serv process is running now!\n"); } return -1; } return 0; } void daemon_init() { //clear file creation mask; umask(0); //become a session leader if (fork() != 0) exit(-1); if (setsid() < 0) exit(-1); //make sure can be never get the TTY control if (fork() != 0) exit(-1); //may chdir here int i; for (i = 0; i < 1024; i++) close(i); /* * Attach file descriptors 0, 1, and 2 to /dev/null. */ int fd0, fd1, fd2; fd0 = open("/dev/null", O_RDWR); fd1 = dup(0); fd2 = dup(0); if (fd0 != 0 || fd1 != 1 || fd2 != 2) { printf("init failed\n"); exit(-1); } } int main(int argc, char **argv) { int listenfd; struct sockaddr_in servaddr; pid_t pid; if (argc != 2) { usage(); return -1; } signal(SIGCHLD, SIG_IGN); len200 = strlen(head200); len404 = strlen(head404); len503 = strlen(head503); daemon_init(); //转为后台程序，如需打印调试，把这行注释掉 if (write_pid() < 0) //避免同时有多个该程序在运行 return -1; if (pipe(fd1) < 0) { perror("pipe failed"); exit(-1); } if (s_pipe(fd2) < 0) { perror("pipe failed"); exit(-1); } int port = atoi(argv[1]); //initialize servaddr and listenfd... bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_port = htons(port); listenfd = socket(AF_INET, SOCK_STREAM, 0); bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)); listen(listenfd, 1000); int i; for (i = 0; i < PRECHILD ; i++) { //父进程预fork 子进程 if ((pid = fork()) < 0) { perror("fork faild"); exit(3); } else if (pid == 0) { answer(listenfd); } else { printf("have create child %d\n", pid); } } char e = 'e'; char c = 'c'; int req_num = 0; int child_num = PRECHILD; REPORT rep; while (1) { //printf("req_num = %d, child_num = %d\n", req_num, child_num); if (read(fd1[0], &rep, sizeof(rep)) < sizeof(rep)) {//等待子进程发来消息 perror("parent read pipe failed"); exit(-1); } //printf("parent: receive from %d\n", pid); if (rep.status == 'n') {//子进程刚accept了新的请求 req_num ++; printf("parent: %d have receive new request\n", rep.pid); if (req_num >= child_num && child_num <= MAXCHILD) { //请求数过多，创建更多子进程 if ((pid = fork()) < 0) { perror("fork faild"); exit(3); } else if (pid == 0) { answer(listenfd); } else { printf("have create child %d\n", pid); child_num ++; } } } else if (rep.status == 'f') {//子进程刚处理完了一个请求 req_num --; //printf("parent: %d have finish a request\n", rep.pid); if (child_num > (req_num + 1) && child_num > PRECHILD) {//子进程数过多，删除多余的子进程 if (write(fd2[1], &e, sizeof(e)) < sizeof(e)) { perror("pa write pipe failed"); exit(-2); } //printf("tell child exit\n"); child_num --; } else { if (write(fd2[1], &c, sizeof(c)) < sizeof(c)) {//让子进程继续等待accept perror("pa write pipe failed"); exit(-2); } //printf("tell child continue\n"); } } } return 0; } 利用fork()创建多个子进程 11:09 pm on Oct 23rd 2010 greenMay 之间我学习了创建一个子进程，也大致理解了子进程与父进程的关系。今天无意间遇到一个创建多个子进程的问题，结果还发现了点小bug，现在写下来和大家分享。 我需要实现的目标如下：编写一段源程序，使系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”;子进程分别显示字符“b”和字符“c”。 一开始我的主要代码如下： view source print? 01 int main() 02 { 03 pid_t child1; 04 pid_t child2; 05 child1 = fork(); 06 child2 = fork(); 07 if(child1 == 0) 08 { 09 printf("Child1:a\n"); 10 return 0; 11 } 12 if(child2 == 0) 13 { 14 printf("Child2:b\n"); 15 return 0; 16 } 17 else 18 { 19 waitpid(child1,NULL,0); 20 waitpid(child2,NULL,0); 21 printf("Parent:c\n"); 22 } 23 return 0; 24 } 奇怪的是，我得到的是这样一个结果： Child1:a Child1:a Child2:b Parent:c 竟然有两个Child1。可是我的代码里明明只是让Chidl1打印一次啊。搜索到一篇好的博文。文章仔细分析了和我几乎相同的情况。事实上，是我的粗心和对fork()的理解不深刻导致了上述的奇怪问题。 我们知道，fork()之后，我们还是首先执行的是父进程，也就是如下代码段： view source print? 1 waitpid(child1,NULL,0); 2 waitpid(child2,NULL,0); 3 printf("Parent:c\n"); 然后waitpid(child1,NULL,0)，进入child1的执行。child1将要执行的是如下的的代码段： view source print? 1 child2 = fork(); 2 if(child1 == 0) 3 { 4 printf("Child1:a\n"); 5 return 0; 6 } 注意，第一行的那个child2 = fork()！这就意味着对于child1来说，它自己又要创建一个子进程，这时候他成为了父亲。这时候，它有一个儿子child2，但是这个child2不同与我们刚才定义的那个child2，这个child2其实是parent的孙子。之所以又打印了一边Child1。如果加上如下代码就明白了： view source print? 01 child2 = fork(); 02 if(child1 == 0) 03 { 04 if(child2 == 0) 05 { 06 printf("GrandChild!\n"); 07 } 08 printf("Child1:a\n"); 09 return 0; 10 } 这时候将出现： Child1:a GrandChild! Child1:a Child2:b Parent:c 恩，这就很明白了！我无意间多调用了一次child2=fork(); 所以，如果要达到我最初的目的，需要改变child2的fork()的位置： view source print? 01 #include 02 #include 03 #include 04 #include 05 int main() 06 { 07 pid_t child1; 08 pid_t child2; 09 child1 = fork(); 10 child2 = fork(); 11 if(child1 == 0) 12 { 13 printf("Child1:a\n"); 14 return 0; 15 } 16 if(child2 == 0) 17 { 18 printf("Child2:b\n"); 19 return 0; 20 } 21 else 22 { 23 waitpid(child1,NULL,0); 24 waitpid(child2,NULL,0); 25 printf("Parent:c\n"); 26 } 27 return 0; 28 } 我参照的那个博文最后给出了一个更为普遍的fork()创建多进程的程序框架： view source print? 01 pid_t create_child() 02 { 03 pid_t p = fork(); 04 if( p == 0 ) 05 { 06 printf("in child %d\n", getpid()); 07 //do something 08 return 0; 09 } 10 return p; 11 } 12 int main(void) 13 { 14 pid_t p1 = create_child(); 15 pid_t p2 = create_child(); 16 17 int st1, st2; 18 waitpid( p1, &st1, 0); 19 waitpid( p2, &st2, 0); 20 printf("in parent, pid = %d\n", getpid()); 21 printf("in parent, child 1 exited with %d\n", st1); 22 printf("in parent, child 2 exited with %d\n", st2); 23 return 0; 24 } 注意到，期中的create_child()函数最后有一个return p。这个return p将pid返回给了父进程，其实也是将子进程对于CPU的控制权交还给了父进程，这样就避免了多个子进程在创建之时互相影响了。 可以说，今天的这个问题真是一个有趣的事情。代码有的时候就是这么奇怪～ 最后，向我引用的那篇文章致敬！ Linux内核对多进程和多线程的支持方式： 线程机制支持并发程序设计技术，在多处理器上能真正保证并行处理。而在linux实现线程很特别，linux把所有的线程都当作进程实现。linux下线程看起来就像普通进程(只是该进程和其他进程共享资源，如地址空间)。上述机制与Microsoft windows或是Sun Solaris实现差异很大。 Linux的线程实现是在核外进行的，核内提供的是创建进程的接口do_fork()。内核提供了两个系统调用__clone()和fork()，最终都用不同的参数调用do_fork()核内API。 do_fork() 提供了很多参数，包括CLONE_VM（共享内存空间）、CLONE_FS（共享文件系统信息）、CLONE_FILES（共享文件描述符表）、CLONE_SIGHAND（共享信号句柄表）和CLONE_PID（共享进程ID，仅对核内进程，即0号进程有效）。当使用fork系统调用产生多进程时，内核调用do_fork()不使用任何共享属性，进程拥有独立的运行环境。当使用pthread_create()来创建线程时，则最终设置了所有这些属性来调用__clone()，而这些参数又全部传给核内的do_fork()，从而创建的”进程”拥有共享的运行环境，只有栈是独立的，由 __clone()传入。 即：Linux下不管是多线程编程还是多进程编程，最终都是用do_fork实现的多进程编程，只是进程创建时的参数不同，从而导致有不同的共享环境。Linux线程在核内是以轻量级进程的形式存在的，拥有独立的进程表项，而所有的创建、同步、删除等操作都在核外pthread库中进行。pthread 库使用一个管理线程（__pthread_manager() ，每个进程独立且唯一）来管理线程的创建和终止，为线程分配线程ID，发送线程相关的信号，而主线程pthread_create()） 的调用者则通过管道将请求信息传给管理线程。 很多朋友都说使用多线程的好处是资源占用少，其隐含之意就是说进程占用资源比线程多，对吧？但实际上Linux下多进程是否就真的点用很多资源呢？暂且不说进程是否比线程占用资源多，就进程占用资源的多少情况而言，Linux确实是做得相当节省的。产生一个多进程时肯定是要产生的一点内存是要复制进程表项，即一个task_struct结构，但这个结构本身做得相当小巧。其它对于一个进程来说必须有的数据段、代码段、堆栈段是不是全盘复制呢？对于多进程来说，代码段是肯定不用复制的，因为父进程和各子进程的代码段是相同的，数据段和堆栈段呢？也不一定，因为在Linux里广泛使用的一个技术叫copy-on-write，即写时拷贝。copy-on-write意味着什么呢？意味着资源节省，假设有一个变量x在父进程里存在，当这个父进程创建一个子进程或多个子进程时这个变量x是否复制到了子进程的内存空间呢？不会的，子进程和父进程使用同一个内存空间的变量，但当子进程或父进程要改变变量x的值时就会复制该变量，从而导致父子进程里的变量值不同。父子进程变量是互不影响的，由于父子进程地址空间是完全隔开的，变量的地址可以是完全相同的。 Linux的”线程”和”进程”实际上处于一个调度层次，共享一个进程标识符空间，这种限制使得不可能在Linux上实现完全意义上的POSIX线程机制，因此众多的Linux线程库实现尝试都只能尽可能实现POSIX的绝大部分语义，并在功能上尽可能逼近。Linux进程的创建是非常迅速的。内核设计与实现一书中甚至指出Linux创建进程的速度和其他针对线程优化的操作系统（Windows,Solaris）创建线程的速度相比，测试结果非常的好，也就是说创建速度很快。由于异步信号是内核以进程为单位分发的，而LinuxThreads的每个线程对内核来说都是一个进程，且没有实现”线程组”，因此，某些语义不符合POSIX标准，比如没有实现向进程中所有线程发送信号，README对此作了说明。LinuxThreads中的线程同步很大程度上是建立在信号基础上的，这种通过内核复杂的信号处理机制的同步方式，效率一直是个问题。LinuxThreads 的问题，特别是兼容性上的问题，严重阻碍了Linux上的跨平台应用（如Apache）采用多线程设计，从而使得Linux上的线程应用一直保持在比较低的水平。在Linux社区中，已经有很多人在为改进线程性能而努力，其中既包括用户级线程库，也包括核心级和用户级配合改进的线程库。目前最为人看好的有两个项目，一个是RedHat公司牵头研发的NPTL（Native Posix Thread Library），另一个则是IBM投资开发的NGPT（Next Generation Posix Threading），二者都是围绕完全兼容POSIX 1003.1c，同时在核内和核外做工作以而实现多对多线程模型。这两种模型都在一定程度上弥补了LinuxThreads的缺点，且都是重起炉灶全新设计的。 综上所述的结论是在Linux下编程多用多进程编程少用多线程编程。 IBM有个家伙做了个测试，发现切换线程context的时候，windows比linux快一倍多。进出最快的锁（windows2k的 critical section和linux的pthread_mutex），windows比linux的要快五倍左右。当然这并不是说linux不好，而且在经过实际编程之后，综合来看我觉得linux更适合做high performance server，不过在多线程这个具体的领域内，linux还是稍逊windows一点。这应该是情有可原的，毕竟unix家族都是从多进程过来的，而 windows从头就是多线程的。 如果是UNIX/linux环境，采用多线程没必要。 多线程比多进程性能高？误导！ 应该说，多线程比多进程成本低，但性能更低。 在UNIX环境，多进程调度开销比多线程调度开销，没有显著区别，就是说，UNIX进程调度效率是很高的。内存消耗方面，二者只差全局数据区，现在内存都很便宜，服务器内存动辄若干G，根本不是问题。 多进程是立体交通系统，虽然造价高，上坡下坡多耗点油，但是不堵车。 多线程是平面交通系统，造价低，但红绿灯太多，老堵车。 我们现在都开跑车，油（主频）有的是，不怕上坡下坡，就怕堵车。 高性能交易服务器中间件，如TUXEDO，都是主张多进程的。实际测试表明，TUXEDO性能和并发效率是非常高的。TUXEDO是贝尔实验室的，与UNIX同宗，应该是对UNIX理解最为深刻的，他们的意见应该具有很大的参考意义 1. 散沙 2010年7月10日08:43 回复 | 引用 | #1 文章很有深度，我们把握一个尺度就可以了，在windows下使用线程，unix下则使用进程就可以了 2. rjoo 2010年9月9日13:49 回复 | 引用 | #2 错的太多了，博主，应该看看新资料了。 现在都2010年了，NPTL早就取代了老的Linux thread。而且通常多线程有性能优势，但是多进程更稳定，并且通常性能瓶颈不在于是进程模型还是线程模型而在于IO。 3. rjoo 2010年9月9日13:56 回复 | 引用 | #3 关于那个critical section和pthread_mutex_t，critical section本质上是一个自旋锁，短期锁当然快，不知道你说的那个IBM的哥们怎么比的，要比也该是和pthread_spinlock_t比。 4. admin 2010年9月9日17:28 回复 | 引用 | #4 rjoo挺热心的，呵呵，这篇文章不是我写的，但有几个地方我可以解答一下： 1. Linux下没有线程的概念，pthread线程实质是通过轻量级进程实现的。你说瓶颈在IO，这一点我很赞同你的意见，作者如果能再写个IO操作的文章来的话就会更好了。 2. mutex和critical section的确是不能比的。一个涉及到内核，一个没有涉及到内核。呵呵，很佩服你对这些东西的掌握程度，有机会多交流。 ^_^ 5. 定时 2010年9月9日17:40 回复 | 引用 | #5 我们组的最近项目的经验告诉我们能用多进程不用多线程，多线程安全编程难，而且锁会早成效率很低，甚至不如单线程，你说的NPTL我知道，他只是多线程优化了并不能改变多线程安全编程的问题，锁的问题。谢谢指教，实践出真知。 @rjoo 6. 定时 2010年9月9日17:44 回复 | 引用 | #6 你说的锁，我确实不太了解，但是我们leader对它很了解，就是最近的一个项目，锁搞得他很郁闷，他也终于同意我的关键，尽可能不用多线程。 @rjoo 7. rjoo 2010年9月29日13:41 回复 | 引用 | #7 @admin Linux下没有线程的概念，pthread线程实质是通过轻量级进程实现的—这是2.4内核以前的情况（实际上是2.0时引入的，那可实在是太久了），2.4内核引入NGPL，2.6内核线程支持改为NPTL。NPTL实现的是1：1的线程模型（有资料说Win也是这种实现，虽然不太确定，但我觉得可能性很大），而NGPT虽然是理论上最先进的m：n线程模型，但最后实现出来的性能差NPTL一大截，最后被抛弃。看看文中说法就知道要么文章写的很早，要么作者看了一堆十年前的资料。 给个链接： http://www.kegel.com/c10k.html#threads.linuxthreads 8. finalday 2010年10月15日17:26 回复 | 引用 | #8 忍不住跳出来说，作者对并发编程的理解还不行。 比如说锁的问题，说得好像是多线程才需要的东西一样。如果一个应用多进程时完全不用锁，多线程也就多一个轻量级锁——锁一下，各回各家，每个线程用自己的专有存储，之后不就和多进程一样了？这样会被搞得很郁闷？当然不会。所以说明那个应用对于数据共享的需求不是这么简单，既然不是这么简单，多进程程序一样要加锁。多进程的加解锁代价可比多线程大得多了，共享数据和协作也麻烦多了。 多线程编程难不难？难，但这是由于并发本身的难度引起的。“锁”，“安全编程”不管是多线程还是多进程都一样会遇到。 多线程的最大优点是数据共享和协作方便。 多进程的最大优点是挂了一个进程不会影响其他进程，资源也不会泄露，故比较能容忍程序员犯错。 至于两者裸奔比性能，真的没啥意义。
初识Ajax(序章)——同步与异步
前言：        经过一段时间的学习和练习初步掌握了ajax，在学习的过程中对重要的知识点进行了整理，发布在csdn上以做“备忘录”，同时希望可以帮助到那些初入前端，对ajax还未掌握或不熟练的学子。本人目前还是大二学生，所学不过皮毛，若文中有错误还请大神能包涵、指教，在此衷心感谢。在学习过程中将之分成了五个部分，由浅入深，从同步→异步、从原生ajax→自己封装ajax→jq框架中ajax的使...
小程序JS同步与异步/Promise对象/async/await精讲
 web前端同步与异步、Promise、async、await ~ 小程序案例讲解JS 异步编程与Promise，还有async与await实例详解，助你提升javascript开发功力
可以用 Task.Run() 将同步方法包装为异步方法吗？
概述本文将会介绍 为什么不推荐对外公开那些使用Task.Run将同步方法包装为异步方法的方法。注：我会对照原文进行逐句翻译，但是考虑到中西方表达方式以及中英文语法的差异，我会适当的修改语句的顺序和陈述方式。此外，限于自身英文和技术水平，有些词或者句子的翻译并不能表达原文的意思，对于这些词语我会同时标注原文用词。引言如果各位学习过或者接触过 C# 中基于任务的异步编程，那么肯定对Task.Ru...
asyncio 简单的原理实现（用同步的方式理解异步）
在理解asyncio异步模块之前，需要理解yield的使用方法，贴一个例子： def test(): data = yield "hello" return data t = test() res = t.send(None) print(res) try: t.send('world') except StopIteration as e: print(e.value) 例子说明：当生成器首次调用send的方法的时候（参数必须是None），test的函数分成了两部分
C++ 语言

64,648

社区成员

250,503

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章