2017-2018-1 20155208 《信息安全系统设计基础》第八周学习总结

第八周课下测试2（课上没完成的同学必做）

服务器源代码：

#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("服务器实现者学号：20155208
");
    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

教材学习及总结

第十一章网络编程

第一节客户端-服务端编程模型

一个应用是由一个服务器进程和一个或者多个客户端进程组成的
客户端和服务端是进程

第二节网络

对于一个主机而言，网络只是又一种I/O设备
物理上而言，网络是一个按照地理远近组成的层次系统。
最底层是LAN（局域网）适配器提供到网络的物理接口以太网段（电缆+集线器）
一台主机可以发送一段位，称为帧每个主机适配器都能看到这个帧，但是只有目的主机实际读取它多个以太网段可以连接成较大的局域网，称为桥接以太网网桥比集线器更充分的利用了电缆带宽互联网络
在层次较高的级别中，多个不兼容的局域网可以通过路由器连接起来，组成互联网络每台路由器对于它所连接到的每个网络都有一个适配器（端口） WAN(广域网）路由器可以用来由各种局域网和广域网构建互联网络
网络协议提供两种基本能力：

命名机制

传送机制

封装是关键

第三节全球IP因特网

因特网的客户端和服务端混合使用套接字接口函数和Unix I/O函数来进行通信
因特网上的主机通过IP地址和域名来标识
TCP/IP实际上是一个协议族
IP机制从某种意义上而言是不可靠的 TCP是一个构建在IP之上的复杂协议，提供了进程间可靠地全双工连接

一、IP地址

一个IP地址就是一个32位无符号整数

IP/TCP为任意整数数据项定义了统一的网络字节顺序（大端字节顺序）

对inet-aton的调用传递的是指向结构的指针，而对inet_ntoa的调用传递的是结构本身

二、因特网域名

域名集合形成一个层次结构，子树称为子域

因特网应用程序通过调用gethostbyname函数和gethostbyaddr函数，从DNS数据库中检索任意的主机条目

gethostbyname函数：返回和域名name相关的主机条目 gethostbyaddr函数：返回和IP地址相关联的主机条目一个IP对多个域名，可供多个域名解析，但域名解析到的地址是一个对一个

三、因特网连接

点对点、全双工、可靠

客户端套接字地址中的端口是由内核自动分配的，称为临时端口

服务端套接字地址中的端口通常是某个知名端口（HTTP：80）

套接字地址：（地址：端口）

第四节套接字接口

套接字接口是一组函数，用以创建网络应用
套接字地址结构

sinfamily成员是AFINET

sin_port成员是一个16位端口

sin_addr成员是32位的IP地址

IP地址和端口号总是以网络字节顺序（大端法）存放的

socket函数

客户端和服务端使用socket函数来创建一个套接字描述符

connect函数

建立和服务器的连接

open_clientfd函数

将socket和connect函数包装而成。客户端可以用它来和服务器建立连接 bind函数、listen函数、accept函数均被服务器用于和客户端建立连接

open_listenfd函数

socket、bind和listen函数结合。用于服务器创建一个监听描述符

第五节 Web服务器

1.协议

Web 客户端和服务器之间的交互用的是一个基于文本的应用级协议，叫做 HTTP (超文本传输协议)

HTTP 是一个简单的协议

一个 Web 客户端(即浏览器) 打开一个到服务器的因特网连接，并且请求某些内容。服务器响应所请求的内容，然后关闭连接。浏览器读取这些内容，并把它显示在屏幕上

Web内容可以用一种叫做 HTML(Hypertext Markup Language，超文本标记语言)的语言来编写。一个 HTML 程序(页)包含指令(标记)，它们告诉浏览器如何显示这页中的各种文本和图形对象

2.内容

对于Web客户端和服务端而言，内容是与一个MIME类型相关的字节序列

Web服务器以两种不同的方式向客户端提供内容：

取一个磁盘文件，并将它的内容返回给客户端。磁盘文件称为静态内容 , 而返回文件给客户端的过程称为服务静态内容运行一个可执行文件，并将它的输出返回给客户端。运行时可执行文件产生的输出称为态内容，而运行程序并返回它的输出到客户端的过程称为服务动态内容每条由Web服务器返回的内容都是和他管理的某个文件相关联的。这些文件每一个都有一个唯一的名字，叫做：URL

第十二章并发编程

程序级并发——进程

函数级并发——线程三种基本的构造并发程序的方法：

进程：每个逻辑控制流是一个进程，由内核进行调度，进程有独立的虚拟地址空间

I/O多路复用：逻辑流被模型化为状态机，所有流共享同一个地址空间

线程：运行在单一进程上下文中的逻辑流，由内核进行调度，共享同一个虚拟地址空间

第一节基于进程的并发编程

构造并发程序最简单的方法——用进程常用函数如下：

fork exec waitpid 构造并发服务器在父进程中接受客户端连接请求，然后创建一个新的子进程来为每个新客户端提供服务。

需要注意的事情： 1.父进程需要关闭它的已连接描述符的拷贝（子进程也需要关闭）

2.必须要包括一个SIGCHLD处理程序来回收僵死子进程的资源

3.父子进程之间共享文件表，但是不共享用户地址空间，这个在以前的学习过程中提到过

关于独立地址空间

1.优点：防止虚拟存储器被错误覆盖

2.缺点：开销高，共享状态信息才需要IPC机制

第二节基于I/O多路复用的并发编程

I/O多路复用技术基本思想：使用select函数要求内核挂起进程，只有在一个或多个I/O事件发生后，才将控制返回给应用程序。

select函数处理类型为fd_set的集合，即描述符集合，并在逻辑上描述为一个大小为n的位向量，每一位b[k]对应描述符k，但当且仅当b[k]=1，描述符k才表明是描述符集合的一个元素。

描述符能做的三件事：

1.分配他们

2.将一个此种类型的变量赋值给另一个变量

3.用FDZERO、FDSET、FDCLR和FDISSET宏指令来修改和检查它们

什么时候可以读？当且仅当一个从该描述符读取一个字节的请求不会阻塞时

注意：每次调用select函数时都需要更新读集合

一、基于I/O多路复用的并发事件驱动服务器

事件驱动程序：将逻辑流模型化为状态机。

状态机：

状态
输入事件
转移对于状态机的理解，参考EDA课程中学习的状态转换图的画法和状态机。

整体的流程是：

select函数检测到输入事件 add_client函数创建新状态机 check_clients函数执行状态转移（在课本的例题中是回送输入行），并且完成时删除该状态机。几个需要注意的函数：

init_pool：初始化客户端池 add_client：添加一个新的客户端到活动客户端池中 check_clients：回送来自每个准备好的已连接描述符的一个文本行二、I/O多路复用技术的优劣

1.优点

相较基于进程的设计，给了程序员更多的对程序程序的控制运行在单一进程上下文中，所以每个逻辑流都可以访问该进程的全部地址空间，共享数据容易实现可以使用GDB调试高效 2.缺点

编码复杂不能充分利用多核处理器第三节基于线程的并发编程

这种模式混合了以上两种方法

线程：就是运行在进程上下文中的逻辑流。

每个线程都有它自己的线程上下文：

一个唯一的整数线程ID——TID 栈栈指针程序计数器通用目的寄存器条件码一、线程执行模型

1.主线程

在每个进程开始生命周期时都是单一线程——主线程，与其他进程的区别仅有：它总是进程中第一个运行的线程。

2.对等线程

某时刻主线程创建，之后两个线程并发运行。

每个对等线程都能读写相同的共享数据。

3.主线程切换到对等线程的原因：

主线程执行一个慢速系统调用，如read或sleep 被系统的间隔计时器中断切换方式是上下文切换

对等线程执行一段时间后会控制传递回主线程，以此类推

4.线程和进程的区别

线程的上下文切换比进程快得多组织形式：进程：严格的父子层次线程：一个进程相关线程组成对等（线程）池，和其他进程的线程独立开来。一个线程可以杀死它的任意对等线程，或者等待他的任意对等线程终止。二、Posix线程

Posix线程是C程序中处理线程的一个标准接口。基本用法是：

线程的代码和本地数据被封装在一个线程例程中每个线程例程都以一个通用指针为输入，并返回一个通用指针。这里需要提到一个万能函数的概念。

万能函数：

void func(void parameter) typedef void (uf)(void para)

即，输入的是指针，指向真正想要传到函数里的数据，如果只有一个就直接让指针指向这个数据，如果是很多就将它们放到一个结构体中，让指针指向这个结构体。后面这个方法就是万能函数的使用思想。线程例程也是这样的。

三、创建线程

1.创建线程：pthread_create函数

#include <pthread.h> typedef void *(func)(void *);

int pthread_create(pthread_t *tid, pthread_attr_t *attr, func *f, void *arg);

成功返回0，出错返回非0 创建一个新的线程，带着一个输入变量arg，在新线程的上下文运行线程例程f。

attr默认为NULL

参数tid中包含新创建线程的ID

2.查看线程ID——pthread_self函数

#include <pthread.h>

pthread_t pthread_self(void);

返回调用者的线程ID（TID）

四、终止线程

1.终止线程的几个方式：

隐式终止：顶层的线程例程返回显示终止：调用pthread_exit函数 *如果主线程调用，会先等待所有其他对等线程终止，再终止主线程和整个进程，返回值为pthread_return

某个对等线程调用Unix的exit函数，会终止进程与其相关线程另一个对等线程通过以当前线程ID作为参数调用pthread_cancle来终止当前线程 2.pthread_exit函数

#include <pthread.h>

void pthread_exit(void *thread_return);

若成功返回0，出错为非0 3.pthread_cancle函数

#include <pthread.h>

void pthread_cancle(pthread_t tid);

若成功返回0，出错为非0

五、回收已终止线程的资源

用pthread_join函数：

#include <pthread.h>

int pthread_join(pthread_t tid,void **thrad_return);

这个函数会阻塞，知道线程tid终止，将线程例程返回的(void*)指针赋值为thread_return指向的位置，然后回收已终止线程占用的所有存储器资源

六、分离线程

在任何一个时间点上，线程是可结合的，或是分离的。

1.可结合的线程

能够被其他线程收回其资源和杀死被收回钱，它的存储器资源没有被释放每个可结合线程要么被其他线程显式的收回，要么通过调用pthread_detach函数被分离 2.分离的线程

不能被其他线程回收或杀死存储器资源在它终止时由系统自动释放 3.pthread_detach函数

#include <pthread.h>

void pthread_detach(pthread_t tid);

若成功返回0，出错为非0 这个函数可以分离可结合线程tid。

线程能够通过以pthreadself()为参数的pthreaddetach调用来分离他们自己。

每个对等线程都应该在他开始处理请求之前分离他自身，以使得系统能在它终止后回收它的存储器资源。

七、初始化线程：pthread_once函数

#include <pthread.h> pthread_once_t once_control = PTHREAD_ONCE_INIT;

int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));

总是返回0

八、基于线程的并发服务器中的注意事项

1.调用pthread_create时，如何将已连接描述符传递给对等进程？

传递指针。

2.竞争问题

见第七节。

3.避免存储器泄露

必须分离每个线程，使它终止时它的存储器资源能被收回。

第四节多线程程序中的共享变量

一个变量是共享的，当且仅当多个线程引用这个变量的某个实例。

一、线程存储器模型

需要注意的有：

寄存器从不共享，虚拟存储器总是共享的。

二、将变量映射到存储器

三、共享变量

变量v是共享的——当且仅当它的一个实例被一个以上的线程引用。

第五节用信号量同步线程

一般而言，没有办法预测操作系统是否将为你的线程选择一个正确的顺序。

一、进度图

进度图是将n个并发线程的执行模型化为一条n维笛卡尔空间中的轨迹线，原点对应于没有任何线程完成一条指令的初始状态。

当n=2时，状态比较简单，是比较熟悉的二维坐标图，横纵坐标各代表一个线程，而转换被表示为有向边

转换规则：

合法的转换是向右或者向上，即某一个线程中的一条指令完成两条指令不能在同一时刻完成，即不允许出现对角线程序不能反向运行，即不能出现向下或向左而一个程序的执行历史被模型化为状态空间中的一条轨迹线。

线程循环代码的分解：

H：在循环头部的指令块 L：加载共享变量cnt到线程i中寄存器%eax的指令。 U：更新（增加）%eax的指令 S：将%eax的更新值存回到共享变量cnt的指令 T：循环尾部的指令块几个概念

临界区：对于线程i，操作共享变量cnt内容的指令L,U,S构成了一个关于共享变量cnt的临界区。不安全区：两个临界区的交集形成的状态安全轨迹线：绕开不安全区的轨迹线具体相关在操作系统课程中讲的更为详细，比如：

临界区使用原则（互斥条件）

有空让进：如果临界区空闲，则只要有进程申请就立即让其进入；无空等待：每次只允许一个进程处于临界区；多中择一：当没有进程在临界区，而同时有多个进程要求进入临界区，只能让其中之一进入临界区，其他进程必须等待；让权等待：进入临界区的进程，不能在临界区内长时间阻塞等待某事件，使其它进程在临界区外无限期等待；不能限制进程的并发数量和执行进度。

二、信号量

信号量实现互斥的基本原理

两个或多个进程通过传递信号进行合作，可以迫使进程在某个位置暂时停止执行（阻塞等待），直到它收到一个可以“向前推进”的信号（被唤醒）；将实现信号灯作用的变量称为信号量，常定义为记录型变量s，其一个域为整型，另一个域为队列，其元素为等待该信号量的阻塞进程(FIFO)。信号量定义：

type semaphore=record count: integer; queue: list of process end; var s:semaphore; 定义对信号量的两个原子操作——P和V

P（wait）

wait(s) s.count :=s.count-1; if s.count<0 then begin 进程阻塞；进程进入s.queue队列； end;

V（signal）

signal(s) s.count :=s.count+1; if s.count ≤0 then begin 唤醒队首进程；将进程从s.queue阻塞队列中移出; end; 需要注意的是，每个信号量在使用前必须初始化。

三、使用信号量来实现互斥

1.基本思想

将每个共享变量（或者一组相关的共享变量）与一个信号量s（初始为1）联系起来，然后用P和V操作将相应的临界区包围起来。

2.几个概念

二元信号量：用这种方式来保护共享变量的信号量叫做二元信号量，取值总是0或者1 互斥锁：以提供互斥为目的的二元信号量加锁：对一个互斥锁执行P操作解锁；对一个互斥锁执行V操作计数信号量：被用作一组可用资源的计数器的信号量禁止区：由于信号量的不变性，没有实际可能的轨迹能够包含禁止区中的状态。

3.wait(s)/signal(s)的应用

进程进入临界区之前，首先执行wait(s)原语，若s.count<0，则进程调用阻塞原语，将自己阻塞，并插入到s.queue队列排队；注意，阻塞进程不会占用处理机时间，不是“忙等”。直到某个从临界区退出的进程执行signal(s)原语，唤醒它；一旦其它某个进程执行了signal(s)原语中的s.count+1操作后，发现s.count ≤0，即阻塞队列中还有被阻塞进程，则调用唤醒原语，把s.queue中第一个进程修改为就绪状态，送就绪队列，准备执行临界区代码。以及

wait操作用于申请资源（或使用权），进程执行wait原语时，可能会阻塞自己； signal操作用于释放资源（或归还资源使用权），进程执行signal原语时，有责任唤醒一个阻塞进程。

三、利用信号量来调度共享资源

信号量有两个作用：

实现互斥

调度共享资源

信号量分为：互斥信号量和资源信号量。

互斥信号量用于申请或释放资源的使用权，常初始化为1；

资源信号量用于申请或归还资源，可以初始化为大于1的正整数，表示系统中某类资源的可用个数。

1.信号量的物理意义

s.count >0表示还可执行wait(s)而不会阻塞的进程数（可用资源数）。每执行一次wait(s)操作，就意味着请求分配一个单位的资源。

当s.count ≤0时，表示已无资源可用，因此请求该资源的进程被阻塞。此时，s.count的绝对值等于该信号量阻塞队列中的等待进程数。执行一次signal操作，就意味着释放一个单位的资源。若s.count<0，表示s.queue队列中还有被阻塞的进程，需要唤醒该队列中的第一个进程，将它转移到就绪队列中。

2.常见问题

这里的常见问题有生产者-消费者问题，和读者-写者问题，都是操作系统课程中详细讲述过的，不再赘述。

第七节其他并发问题

一、线程安全性

一个线程是安全的，当且仅当被多个并发线程反复的调用时，它会一直产生正确的结果。

四个不相交的线程不安全函数类以及应对措施：

不保护共享变量的函数——用P和V这样的同步操作保护共享变量保持跨越多个调用的状态的函数——重写，不用任何static数据。返回指向静态变量的指针的函数——①重写；②使用加锁-拷贝技术。调用线程不安全函数的函数——参考之前三种

二、可重入性

当它们被多个线程调用时，不会引用任何共享数据。

1.显式可重入的：

所有函数参数都是传值传递，没有指针，并且所有的数据引用都是本地的自动栈变量，没有引用静态或全剧变量。

2.隐式可重入的：

调用线程小心的传递指向非共享数据的指针。

三、在线程化的程序中使用已存在的库函数

一句话，就是使用线程不安全函数的可重入版本，名字以_r为后缀结尾。

四、竞争

1.竞争发生的原因：

一个程序的正确性依赖于一个线程要在另一个线程到达y点之前到达它的控制流中的x点。也就是说，程序员假定线程会按照某种特殊的轨迹穿过执行状态空间，忘了一条准则规定：线程化的程序必须对任何可行的轨迹线都正确工作。

2.消除方法：

动态的为每个整数ID分配一个独立的块，并且传递给线程例程一个指向这个块的指针

五、死锁：

一组线程被阻塞了，等待一个永远也不会为真的条件。

解决死锁的方法

1.不让死锁发生：

静态策略：设计合适的资源分配算法，不让死锁发生---死锁预防；动态策略：进程在申请资源时，系统审查是否会产生死锁，若会产生死锁则不分配---死锁避免。 2.让死锁发生：

进程申请资源时不进行限制，系统定期或者不定期检测是否有死锁发生，当检测到时解决死锁----死锁检测与解除。

代码托管

代码上传截图：

码云链接

学习进度条

	代码行数（新增/积累）	博客量（新增/积累	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	5/5	1/1	8/8
第二周	120/120	1/1	12/12
第三周	100/100	1/1	15/15
第四周	80/80	1/1	9/9
第五周	50/50	1/1	6/6
第六周	350/350	1/1	12/12
第七周	120/120	2/2	15/15
第八周	380/380	1/1	16/16

参考资料

《深入理解计算机系统V3》学习指导

相关阅读:
Sqlserver @@IDENTITY 和 SCOPE_IDENTITY() 的使用
 Sqlserver 其它操作
 将 .net core 通过容器docker 部署到 linux 记录
 Unity中使用ProtocolBuffer
Android笔记基于https://www.bilibili.com/video/BV1Bf4y1D7Gq?p=1
简单登陆界面的应用
 springboot 梳理7--整合redis（待完善）
4.工厂方式建立
 5，db的解决方法，日志集成
 10.3右上角后台逻辑处理，前台处理
原文地址：https://www.cnblogs.com/xuzihan/p/7823014.html

2017-2018-1 20155208 《信息安全系统设计基础》第八周学习总结

2017-2018-1 20155208 《信息安全系统设计基础》第八周学习总结

第八周课下测试2（课上没完成的同学必做）

第八周课下测试1

教材学习及总结

第十一章 网络编程

第一节 客户端-服务端编程模型

第二节 网络

第三节 全球IP因特网

一、IP地址

二、因特网域名

三、因特网连接

第四节 套接字接口

第五节 Web服务器

第十二章 并发编程

第一节 基于进程的并发编程

第二节 基于I/O多路复用的并发编程

代码托管

学习进度条

参考资料

第十一章网络编程

第一节客户端-服务端编程模型

第二节网络

第三节全球IP因特网

第四节套接字接口

第十二章并发编程

第一节基于进程的并发编程

第二节基于I/O多路复用的并发编程