2017-2018-1 20155304 《信息安全系统设计基础》第八周学习总结
课上测试补充
第八周测试-2
把第一个练习中的代码在X86-64（Ubuntu）中反汇编，给出汇编代码和机器码的截图
把X86-64汇编翻译成Y86-64汇编，并给出相应机器码的截图（使用附件中的Y86-64模拟器）
原代码：
#include <stdlib.h>
#include <stdio.h>
int main(int argc,char *argv[])
{
int i,sum=0;
for(i=0;i<argc;i++)
{
sum+=atoi(argv[i]);
}
printf("Total: %d
",sum);
return 0;
}
X86-64汇编：
.file "sum.c"
.section .rodata
.LC0:
.string "Total: %d
"
.text
.globl main
.type main, @function
main:
.LFB2:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $32, %rsp
movl %edi, -20(%rbp)
movq %rsi, -32(%rbp)
movl $0, -4(%rbp)
movl $0, -8(%rbp)
jmp .L2
.L3:
movl -8(%rbp), %eax
cltq
leaq 0(,%rax,8), %rdx
movq -32(%rbp), %rax
addq %rdx, %rax
movq (%rax), %rax
movq %rax, %rdi
call atoi
addl %eax, -4(%rbp)
addl $1, -8(%rbp)
.L2:
movl -8(%rbp), %eax
cmpl -20(%rbp), %eax
jl .L3
movl -4(%rbp), %eax
movl %eax, %esi
movl $.LC0, %edi
movl $0, %eax
call printf
movl $0, %eax
leave
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE2:
.size main, .-main
.ident "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609"
.section .note.GNU-stack,"",@progbits
机器码：
0000000000000000 <main>:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 20 sub $0x20,%rsp
8: 89 7d ec mov %edi,-0x14(%rbp)
b: 48 89 75 e0 mov %rsi,-0x20(%rbp)
f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
16: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%rbp)
1d: eb 26 jmp 45 <main+0x45>
1f: 8b 45 f8 mov -0x8(%rbp),%eax
22: 48 98 cltq
24: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
2b: 00
2c: 48 8b 45 e0 mov -0x20(%rbp),%rax
30: 48 01 d0 add %rdx,%rax
33: 48 8b 00 mov (%rax),%rax
36: 48 89 c7 mov %rax,%rdi
39: e8 00 00 00 00 callq 3e <main+0x3e>
3e: 01 45 fc add %eax,-0x4(%rbp)
41: 83 45 f8 01 addl $0x1,-0x8(%rbp)
45: 8b 45 f8 mov -0x8(%rbp),%eax
48: 3b 45 ec cmp -0x14(%rbp),%eax
4b: 7c d2 jl 1f <main+0x1f>
4d: 8b 45 fc mov -0x4(%rbp),%eax
50: 89 c6 mov %eax,%esi
52: bf 00 00 00 00 mov $0x0,%edi
57: b8 00 00 00 00 mov $0x0,%eax
5c: e8 00 00 00 00 callq 61 <main+0x61>
61: b8 00 00 00 00 mov $0x0,%eax
66: c9 leaveq
67: c3 retq
Y86-64汇编：
.file "sum.c"
.section .rodata
.LC0:
.string "Total: %d
"
.text
.globl main
.type main, @function
main:
.LFB2:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $32, %rsp
irmovq %edi, -20(%rbp)
irmovq %rsi, -32(%rbp)
irmovlq $0, -4(%rbp)
irmovlq $0, -8(%rbp)
jmp .L2
.L3:
movl -8(%rbp), %eax
cltq
leaq 0(,%rax,8), %rdx
movq -32(%rbp), %rax
addq %rdx, %rax
movq (%rax), %rax
movq %rax, %rdi
call atoi
addl %eax, -4(%rbp)
addl $1, -8(%rbp)
.L2:
movlq -8(%rbp), %eax
cmpl -20(%rbp), %eax
jl .L3
movl -4(%rbp), %eax
movl %eax, %esi
movl $.LC0, %edi
movl $0, %eax
call printf
movl $0, %eax
leave
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE2:
.size main, .-main
.ident "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609"
.section .note.GNU-stack,"",@progbits
第八周测试-3
基于socket 使用教材的csapp.h csapp.c,实现daytime(13)服务器（端口我们使用13+后三位学号）和客户端
服务器响应消息格式是
“
客户端IP：XXXX
服务器实现者学号：XXXXXXXX
当前时间： XX：XX：XX
”
- 多进程实现daytime服务器
服务器端原代码：
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <unistd.h> // for fork
#include <sys/signal.h> // for signal
#include <sys/wait.h> // for wait
#include <time.h>
#include <arpa/inet.h>
#define HELLO_WORLD_SERVER_PORT 6666
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
void reaper(int sig)
{
int status;
//调用wait3读取子进程的返回值,使zombie状态的子进程彻底释放
while(wait3(&status,WNOHANG,(struct rusage*)0) >=0)
;
}
int main(int argc, char **argv)
{
//设置一个socket地址结构server_addr,代表服务器internet地址, 端口
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr)); //把一段内存区的内容全部设置为0
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
time_t t;
//创建用于internet的流协议(TCP)socket,用server_socket代表服务器socket
int server_socket = socket(AF_INET,SOCK_STREAM,0);
if( server_socket < 0)
{
printf("Create Socket Failed!
");
exit(1);
}
//把socket和socket地址结构联系起来
if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
{
printf("Server Bind Port : %d Failed!
", HELLO_WORLD_SERVER_PORT);
exit(1);
}
//server_socket用于监听
if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
{
printf("Server Listen Failed!");
exit(1);
}
//通知操作系统,当收到子进程的退出信号(SIGCHLD)时,执行reaper函数,释放zombie状态的进程
(void)signal(SIGCHLD,reaper);
while (1) //服务器端要一直运行
{
//定义客户端的socket地址结构client_addr
struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);
//接受一个到server_socket代表的socket的一个连接
//如果没有连接请求,就等待到有连接请求--这是accept函数的特性
//accept函数返回一个新的socket,这个socket(new_server_socket)用于同连接到的客户的通信
//new_server_socket代表了服务器和客户端之间的一个通信通道
//accept函数把连接到的客户端信息填写到客户端的socket地址结构client_addr中
int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
if ( new_server_socket < 0)
{
printf("Server Accept Failed!
");
break;
}
int child_process_pid = fork(); //fork()后,子进程是主进程的拷贝
//在主进程和子进程中的区别是fork()的返回值不同.
if(child_process_pid == 0 )//如果当前进程是子进程,就执行与客户端的交互
{
t=time(NULL);
close(server_socket); //子进程中不需要被复制过来的server_socket
char buffer[BUFFER_SIZE];
bzero(buffer, BUFFER_SIZE);
//strcpy(buffer,"20155304实现");
strcat(buffer,"
"); //C语言字符串连接
//发送buffer中的字符串到new_server_socket,实际是给客户端
send(new_server_socket,buffer,BUFFER_SIZE,0);
printf("服务器实现者学号：20155304
");
printf("客户端IP：%s
",inet_ntoa(client.sin_addr));
printf("当前时间： %s
",ctime(&t));
send(new_server_socket,(void *)&t,sizeof(time_t),0);
bzero(buffer,BUFFER_SIZE);
//接收客户端发送来的信息到buffer中
length = recv(new_server_socket,buffer,BUFFER_SIZE,0);
if (length < 0)
{
printf("Server Recieve Data Failed!
");
exit(1);
}
printf("
%s
",buffer);
//关闭与客户端的连接
close(new_server_socket);
exit(0);
}
else if(child_process_pid > 0) //如果当前进程是主进程
close(new_server_socket); //主进程中不需要用于同客户端交互的new_server_socket
}
//关闭监听用的socket
close(server_socket);
return 0;
}
客户端原代码：
#include <netinet/in.h> // for sockaddr_in
#include <sys/types.h> // for socket
#include <sys/socket.h> // for socket
#include <stdio.h> // for printf
#include <stdlib.h> // for exit
#include <string.h> // for bzero
#include <time.h>
#define HELLO_WORLD_SERVER_PORT 6666
#define BUFFER_SIZE 1024
void talk_to_server(char ** argv)
{
//设置一个socket地址结构client_addr,代表客户机internet地址, 端口
struct sockaddr_in client_addr;
bzero(&client_addr,sizeof(client_addr)); //把一段内存区的内容全部设置为0
client_addr.sin_family = AF_INET; //internet协议族
client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自动获取本机地址
client_addr.sin_port = htons(0); //0表示让系统自动分配一个空闲端口
//创建用于internet的流协议(TCP)socket,用client_socket代表客户机socket
int client_socket = socket(AF_INET,SOCK_STREAM,0);
time_t t;
if( client_socket < 0)
{
printf("Create Socket Failed!
");
exit(1);
}
//把客户机的socket和客户机的socket地址结构联系起来
if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
{
printf("Client Bind Port Failed!
");
exit(1);
}
//设置一个socket地址结构server_addr,代表服务器的internet地址, 端口
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family = AF_INET;
if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //服务器的IP地址来自程序的参数
{
printf("Server IP Address Error!
");
exit(1);
}
server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
socklen_t server_addr_length = sizeof(server_addr);
//向服务器发起连接,连接成功后client_socket代表了客户机和服务器的一个socket连接
if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
{
printf("Can Not Connect To %s!
",argv[1]);
exit(1);
}
char buffer[BUFFER_SIZE];
bzero(buffer,BUFFER_SIZE);
//从服务器接收数据到buffer中
int length = recv(client_socket,buffer,BUFFER_SIZE,0);
if(length < 0)
{
printf("Recieve Data From Server %s Failed!
", argv[1]);
exit(1);
}
printf("From Server %s : %s
",argv[1],buffer);
length = recv(client_socket,(void *)&t,sizeof(time_t),0);
if(length < 0)
{
printf("Recieve Data From Server %s Failed!
", argv[1]);
exit(1);
}
printf("当前时间： %s
",ctime(&t));
bzero(buffer,BUFFER_SIZE);
//strcpy(buffer,"Thanks!");
//向服务器发送buffer中的数据
send(client_socket,buffer,BUFFER_SIZE,0);
//关闭socket
close(client_socket);
}
int main(int argc, char **argv)
{
if (argc != 2)
{
printf("Usage: .\%s ServerIPAddress
",argv[0]);
exit(1);
}
talk_to_server(argv);
return 0;
}
- 多线程实现daytime服务器
服务器源代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <errno.h>
#include <time.h>
#define PORT 1234
#define BACKLOG 2
#define MAXDATASIZE 1000
void process_cli(int connectfd,struct sockaddr_in client);
void sig_handler(int s);
int main()
{
int opt,listenfd,connectfd;
pid_t pid;
struct sockaddr_in server;
struct sockaddr_in client;
int sin_size;
struct sigaction act;
struct sigaction oact;
act.sa_handler=sig_handler;
sigemptyset(&act.sa_mask);
act.sa_flags=0;
printf("服务器实现者学号：20155304
");
if(sigaction(SIGCHLD,&act,&oact)<0)
{
perror("Sigaction failed!
");
exit(1);
}
if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("Creating socket failed.
");
exit(1);
}
opt=SO_REUSEADDR;
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr.s_addr=htonl(INADDR_ANY);
if(bind(listenfd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)
{
perror("Bind error.
");
exit(1);
}
if(listen(listenfd,BACKLOG)==-1)
{
perror("listen() error.
");
exit(1);
}
sin_size=sizeof(struct sockaddr_in);
while(1)
{
if((connectfd=accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1)
{
if(errno==EINTR) continue;
perror("accept() error.
");
exit(1);
}
if((pid=fork())>0)
{
close(connectfd);
continue;
}
else if(pid==0)
{
close(listenfd);
process_cli(connectfd,client);
exit(0);
}
else
{
printf("fork error.
");
exit(1);
}
}
close(listenfd);
return 0;
}
void process_cli(int connectfd,struct sockaddr_in client)
{
int i,num;
char recvbuf[MAXDATASIZE];
char sendbuf[MAXDATASIZE];
char cli_name[MAXDATASIZE];
time_t t;
t=time(NULL);
printf("客户端IP：%s
",inet_ntoa(client.sin_addr));
num=recv(connectfd,cli_name,MAXDATASIZE,0);
if(num==0)
{
close(connectfd);
printf("Client disconnected.
");
return;
}
send(connectfd,(void *)&t,sizeof(time_t),0);
while(num=recv(connectfd,recvbuf,MAXDATASIZE,0))
{
recvbuf[num]=' ';
printf("当前时间：%s
",ctime(&t));
//send(connectfd,(void *)&t,sizeof(time_t),0);
}
close(connectfd);
}
void sig_handler(int s)
{
pid_t pid;
int stat;
while((pid=waitpid(-1,&stat,WNOHANG))>0)
printf("子进程 %d 关闭。
",pid);
return;
}
客户端源代码：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <time.h>
#define PORT 1234
#define MAXDATASIZE 1000
void process(FILE *fp,int sockfd);
char *getMessage(char *sendline,int len,FILE *fp);
int main(int argc,char *argv[])
{
int fd;
struct hostent *he;
struct sockaddr_in server;
if(argc!=2)
{
printf("Usage: %s <IP Address>
",argv[0]);
exit(1);
}
if((he=gethostbyname(argv[1]))==NULL)
{
printf("gethostbyname error.
");
exit(1);
}
if((fd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket() error.
");
exit(1);
}
bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr=*((struct in_addr *)he->h_addr);
if(connect(fd,(struct sockaddr *)&server,sizeof(struct sockaddr))==-1)
{
perror("connect() error.
");
exit(1);
}
process(stdin,fd);
close(fd);
return 0;
}
void process(FILE *fp,int sockfd)
{
char sendbuf[MAXDATASIZE];
char recvbuf[MAXDATASIZE];
int num;
time_t t;
t=time(NULL);
printf("用户名：
");
if(fgets(sendbuf,MAXDATASIZE,fp)==NULL)
{
printf("lease enter your name,now you have exit.
");
return;
}
send(sockfd,sendbuf,strlen(sendbuf),0);
while(getMessage(sendbuf,MAXDATASIZE,fp)!=NULL)
{
send(sockfd,sendbuf,strlen(sendbuf),0);
if((num=recv(sockfd,recvbuf,MAXDATASIZE,0))==0)
{
printf("Server no send you any data.
");
return;
}
recvbuf[num]=' ';
printf("服务器消息：%s
",ctime(&t));
}
printf("Exit.
");
}
char *getMessage(char *sendline,int len,FILE *fp)
{
printf("请输入请求:
");
return(fgets(sendline,len,fp));
}
课下作业
第八周课下作业1
1 完成家庭作业4.47，4.48，4.49
2 相应代码反汇编成X86-64汇编
3 把上述X86-64汇编翻译成Y86汇编，并给出相应机器码
源代码：
void bubble(int *data, int count) {
if(count == 0)
return;
int i, j;
int *p, *q;
for(i=count-1; i!=0; i--){
p = data, q = data + 1;
for(j=0; j!=i; ++j)
{
if( *p > *q )
{
int t = *p;*p = *q;
*q = t;
}
p++, q++;}
}}
X86-64汇编
00000000 <bubble_p>:
0: 56 push %esi
1: 53 push %ebx
2: 8b 44 24 10 mov 0x10(%esp),%eax
6: 8b 54 24 0c mov 0xc(%esp),%edx
a: 8d 70 ff lea -0x1(%eax),%esi
d: 85 f6 test %esi,%esi
f: 7e 2d jle 3e <bubble_p+0x3e>
11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
18: 31 c0 xor %eax,%eax
1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
20: 8b 4c 82 04 mov 0x4(%edx,%eax,4),%ecx
24: 8b 1c 82 mov (%edx,%eax,4),%ebx
27: 39 d9 cmp %ebx,%ecx
29: 7d 07 jge 32 <bubble_p+0x32>
2b: 89 5c 82 04 mov %ebx,0x4(%edx,%eax,4)
2f: 89 0c 82 mov %ecx,(%edx,%eax,4)
32: 83 c0 01 add $0x1,%eax
35: 39 f0 cmp %esi,%eax
37: 7c e7 jl 20 <bubble_p+0x20>
39: 83 ee 01 sub $0x1,%esi
3c: 75 da jne 18 <bubble_p+0x18>
3e: 5b pop %ebx
3f: 5e pop %esi
Disassembly of section .text.startup:
00000000 <main>:
0: 31 c0 xor %eax,%eax
Y86汇编：
0x0000: | Disassembly of section .text:
|
0x0000: | 00000000 <bubble_p>:
0x0000: | 0: 56 push %esi
0x0000: | 1: 53 push %ebx
0x0000: | 2: 8b 44 24 10 mov 0x10(%esp),%eax
0x0000: | 6: 8b 54 24 0c mov 0xc(%esp),%edx
0x0000: | a: 8d 70 ff lea -0x1(%eax),%esi
0x0000: | d: 85 f6 test %esi,%esi
0x0000: | f: 7e 2d jle 3e <bubble_p+0x3e>
0x0000: | 11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
0x0000: | 18: 31 c0 xor %eax,%eax
0x0000: | 1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
0x0000: | 20: 8b 4c 82 04 mov 0x4(%edx,%eax,4),%ecx
0x0000: | 24: 8b 1c 82 mov (%edx,%eax,4),%ebx
0x0000: | 27: 39 d9 cmp %ebx,%ecx
0x0000: | 29: 7d 07 jge 32 <bubble_p+0x32>
0x0000: | 2b: 89 5c 82 04 mov %ebx,0x4(%edx,%eax,4)
0x0000: | 2f: 89 0c 82 mov %ecx,(%edx,%eax,4)
0x0000: | 32: 83 c0 01 add $0x1,%eax
0x0000: | 35: 39 f0 cmp %esi,%eax
0x0000: | 37: 7c e7 jl 20 <bubble_p+0x20>
0x0000: | 39: 83 ee 01 sub $0x1,%esi
0x0000: | 3c: 75 da jne 18 <bubble_p+0x18>
0x0000: | 3e: 5b pop %ebx
0x0000: | 3f: 5e pop %esi
|
0x0000: | Disassembly of section .text.startup:
|
0x0000: | 00000000 <main>:
0x0000: | 0: 31 c0 xor %eax,%eax
|
|
第八周课下作业2
把课上练习3的daytime服务器分别用多进程和多线程实现成并发服务器并测试
用多进程实现并发服务器
修改源代码如下：
while (1) {
connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);
if (Fork() == 0) {
Close(listenfd); /* Child closes its listening socket */
echo(connfd); /* Child services client */
Close(connfd); /* Child closes connection with client */
exit(0); /* Child exits */
}
Close(connfd); /* Parent closes connected socket (important!) */
}
用线程实现并发服务器
#include "csapp.h"
void echo(int connfd);
void *thread(void *vargp);
int main(int argc, char **argv)
{
int listenfd, *connfdp, port, clientlen=sizeof(struct sockaddr_in);
struct sockaddr_in clientaddr;
pthread_t tid;
if (argc != 2) {
fprintf(stderr, "usage: %s <port>
", argv[0]);
exit(0);
}
port = atoi(argv[1]);
listenfd = Open_listenfd(port);
while (1) {
connfdp = Malloc(sizeof(int));
*connfdp = Accept(listenfd, (SA *) &clientaddr, &clientlen);
Pthread_create(&tid, NULL, thread, connfdp);
}
}
/* thread routine */
void *thread(void *vargp)
{
int connfd = *((int *)vargp);
Pthread_detach(pthread_self());
Free(vargp);
echo(connfd);
Close(connfd);
return NULL;
}
void echo(int connfd)
{
size_t n;
char buf[MAXLINE];
rio_t rio;
Rio_readinitb(&rio, connfd);
while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) {
printf("客户端IP:127.0.0.1
");
printf("服务器实现学号:20155218
");
printf("server received %d bytes
", n);
time_t t;
time(&t);
printf("当前时间:%s
",ctime(&t));
Rio_writen(connfd, buf, n);
}
}
教材学习内容总结
进程
- 构造并发程序最简单的方法就是用进程。
一个构造并发服务器的自然方法就是，在父进程中接受客户端连接请求，然后创建一个新的子进程来为每个新客户端提供服务。
- 基于进程的并发服务器
通常服务器会运行很长的时间，所以我们必须要包括一个 SIGCHLD 处理程序，来回收僵死 (zombie) 子进程的资源。当 SIGCHLD 处理程序执行时， SIGCHLD 信号是阻塞的，而 Unix 信号是不排队的。
父子进程必须关闭它们各自的 connfd 拷贝。父进程必须关闭它的已连接描述符，以避免存储器泄漏。直到父子进程的 connfd 都关闭了，到客户端的连接才会终止。
- 进程的优劣
优点：一个进程不可能不小心覆盖另一个进程的虚拟存储器，这就消除了许多令人迷惑的错误。
缺点：独立的地址空间使得进程共享状态信息变得更加困难。为了共享信息，它们必须使用显式的IPC(进程间通信)机制。基于进程的设计的另一个缺点是，它们往往比较慢，因为进程控制和 IPC 的开销很高。
线程
- 线程定义：线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。
- 线程种类： 线程有两种。一种是用户级线程：管理过程全部由用户程序完成，操作系统内核心只对进程进行管理。另外一种是核心级线程：由操作系统内核进行管理。操作系统内核给应用程序提供相应的系统调用和应用程序接口API，以使用户程序可以创建、执行、撤消线程。
- 进程与线程区别：
- 地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
- 通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
- 调度和切换：线程上下文切换比进程上下文切换要快得多。
- 在多线程OS中，进程不是一个可执行的实体。
I/O多路复用
- 可以用作并发事件驱动程序的基础。
- 将逻辑流模型化为状态机：由一组状态、输入事件和转移，其中转移就是将状态和输入事件映射到状态。
- 比基于进程的设计给了程序员更多的对程序行为的控制，是运行在单一进程上下文中的。但是代码复杂，不能充分利用多核处理器。
教材学习中的问题和解决过程
无
代码调试中的问题和解决过程
无
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 30篇 | 400小时 | |
| 第一周 | 47/100 | 1/1 | 10/10 | |
| 第二周 | 180/200 | 1/1 | 10/10 | |
| 第三周 | 200/300 | 1/1 | 10/10 | |
| 第五周 | 190/300 | 1/1 | 10/10 | |
| 第六周 | 220/300 | 2/2 | 10/10 | |
| 第七周 | 320/500 | 2/2 | 10/10 | |
| 第八周 | 320/500 | 3/3 | 10/10 |
尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。
耗时估计的公式
：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。
-
计划学习时间:XX小时
-
实际学习时间:XX小时
-
改进情况：
(有空多看看现代软件工程 课件
软件工程师能力自我评价表)