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

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

找出全书你认为最重要的一章，深入重新学习一下，要求（期末占10分）：

  • 完成这一章所有习题

  • 详细总结本章要点

  • 给你的结对学习搭档讲解你的总结并获取反馈

  • 我选择课本的第十二章，因为第12章主要讲了程序的并发编程，一个并发编程是由在时间上重叠的一组逻辑流组成的。这章主要学习了三种不同的并发机制：进程，I/O多路复用和线程。无论哪种并发机制，同步对共享数据的并发访问都是一个困难性问题，提出对信号量的p,v操作去解决这个问题。信号量操作可以用来提供对共享数据的互斥访问，也对类似生产者，消费者程序中有限缓冲区和读者写者系统中的共享对象这样的资源访问进行调度。

教材学习内容总结

第12章：

并发编程

  • 程序级并发——进程

  • 函数级并发——线程

三种基本的构造并发程序的方法：

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

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

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

基于进程的并发编程

  • 构造并发程序最简单的方法——用进程。常用函数如下：fork，exec，waitpid
    构造并发服务器：在父进程中接受客户端连接请求，然后创建一个新的子进程来为每个新客户端提供服务。
    需要注意的事情：

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

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

3.父子进程之间共享文件表，但是不共享用户地址空间
独立地址空间的优点是防止虚拟存储器被错误覆盖，缺点是开销高，共享状态信息才需要IPC机制

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

  • I/O多路复用技术使用select函数要求内核挂起进程，只有在一个或多个I/O事件发生后，才将控制返回给应用程序。
    select函数处理类型为fd_set的集合，即描述符集合，并在逻辑上描述为一个大小为n的位向量，每一位b[k]对应描述符k，但当且仅当b[k]=1，描述符k才表明是描述符集合的一个元素。
    描述符能做的三件事：
1、分配他们
2、将一个此种类型的变量赋值给另一个变量
3、用FD_ZERO、FD_SET、FD_CLR和FD_ISSET宏指令来修改和检查它们
当且仅当一个从该描述符读取一个字节的请求不会阻塞时，描述符k表示准备好可以读了
我们必须在每次调用select时都更新读集合
事件驱动程序：将逻辑流模型化为状态机。
一个状态机就是一组状态、输入事件和转移，其中转移就是将状态和输入事件映射到状态。

  • 基于I/O多路复用的并发事件驱动服务器的流程如下：

基于线程的并发编程

  • 线程：就是运行在进程上下文中的逻辑流。
    线程由内核自动调度。每个线程都有它自己的线程上下文：
•一个唯一的整数线程ID——TID

•栈

•栈指针

•程序计数器

•通用目的寄存器

•条件码

线程执行模型

  • 在每个进程开始生命周期时都是单一线程——主线程，与其他进程的区别仅有：它总是进程中第一个运行的线程。
  • 对等线程是某时刻主线程创建，之后两个线程并发运行每个对等线程都能读写相同的共享数据。
  • 主线程切换到对等线程的方式是上下文切换，对等线程执行一段时间后会控制传递回主线程，以此类推，切换的原因是：
•主线程执行一个慢速系统调用，如read或sleep

•被系统的间隔计时器中断
  • 线程和进程的区别:
线程的上下文切换比进程快得多

组织形式： 

进程：严格的父子层次
            
线程：一个进程相关线程组成对等（线程）池，和其他进程的线程独立开来。一个线程可以杀死它的任意对等线程，或者等待他的任意对等线程终止

Posix线程

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

创建线程

  • 创建线程：pthread_create函数，返回时参数tid包含新创建线程的ID
  • 查看线程ID：pthread_self函数，返回调用者的线程ID（TID）

终止线程

  • 终止线程的几个方式：

回收已终止线程的资源

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

分离线程

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

1.能够被其他线程收回其资源和杀死

2.被收回钱，它的存储器资源没有被释放

3.每个可结合线程要么被其他线程显式的收回，要么通过调用pthread_detach函数被分离

  • 分离的线程

1.不能被其他线程回收或杀死

2.存储器资源在它终止时由系统自动释放

  • pthread_detach函数可以分离可结合线程tid。
  • 线程能够通过以pthread_self()为参数的pthread_detach调用来分离他们自己。
  • 每个对等线程都应该在他开始处理请求之前分离他自身，以使得系统能在它终止后回收它的存储器资源。

初始化线程

  • pthread_once函数允许你初始化与线程例程相关的状态，总是返回0.

一个基于线程的并发服务器

  • 调用pthread_create时，用传递指针的方法将已连接描述符传递给对等进程
  • 避免存储器泄露，必须分离每个线程，使它终止时它的存储器资源能被收回。

多线程程序中的共享变量

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

线程存储器模型

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

将变量映射到存储器

共享变量

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

用信号量同步线程

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

进度图

  • 进度图是将n个并发线程的执行模型化为一条n维笛卡尔空间中的轨迹线，原点对应于没有任何线程完成一条指令的初始状态。
  • 当n=2时，状态比较简单，是比较熟悉的二维坐标图，横纵坐标各代表一个线程，而转换被表示为有向边
  • 转换规则：
合法的转换是向右或者向上，即某一个线程中的一条指令完成

两条指令不能在同一时刻完成，即不允许出现对角线

程序不能反向运行，即不能出现向下或向左
而一个程序的执行历史被模型化为状态空间中的一条轨迹线
  • 线程循环代码的分解：

H：在循环头部的指令块

L：加载共享变量cnt到线程i中寄存器%eax的指令。

U：更新（增加）%eax的指令

S：将%eax的更新值存回到共享变量cnt的指令

T：循环尾部的指令块

  • 几个概念：

临界区：对于线程i，操作共享变量cnt内容的指令L,U,S构成了一个关于共享变量cnt的临界区。

不安全区：两个临界区的交集形成的状态

安全轨迹线：绕开不安全区的轨迹线

信号量

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

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;
  • 需要注意的是，每个信号量在使用前必须初始化。

使用信号量来实现互斥

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

二元信号量：用这种方式来保护共享变量的信号量叫做二元信号量，取值总是0或者1.

互斥锁：以提供互斥为目的的二元信号量

加锁：对一个互斥锁执行P操作

解锁；对一个互斥锁执行V操作

计数信号量：被用作一组可用资源的计数器的信号量

禁止区：由于信号量的不变性，没有实际可能的轨迹能够包含禁止区中的状态。

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

  • 信号量有两个作用：实现互斥；调度共享资源
  • 信号量分为：互斥信号量和资源信号量。

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

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

  • 常见问题有生产者-消费者问题，和读者-写者问题

  • 在输入692页代码时：第四行是主线程代码的开始，主线程通过调用pthread_create函数创建了一个新的对等线程，在pthread_join中主线程等待对等线程终止。在*thread中定义了对等的线程，只打印了一个字符串。
    image

  • 在运行hellosingle.c时，这个程序很简单，是一个单线程，对程序进行分析得到：调用了两遍print_msg函数,每次调用把传入的字符串打印了五遍。

#include <stdio.h>
#define NUM 5
void    print_msg(char *);
int main()
{
    print_msg("hello");
    print_msg("world\n");
}
void print_msg(char *m)
{
    int i;
    for(i=0 ; i<NUM ; i++){
        printf("%s", m);
        fflush(stdout);
        sleep(1);
    }
}
  • 在运行老师给的代码：可以看出，wait函数用于等待信号，signal函数用于通知信号。其中wait函数中有一次对mutex的释放和重新获取操作，因此生产者和消费者并不会出现死锁。也就是消费者等待生产者产出产品后才打印，否则消费者阻塞等待生产者生产。
#include <stdlib.h>
#include <pthread.h>
#include <stdlib.h>

typedef struct _msg{
    struct _msg * next;
    int num;
} msg;

msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer ( void * p )
{
    msg * mp;

    for( ;; ) {
        pthread_mutex_lock( &lock );
        while ( head == NULL )
            pthread_cond_wait( &has_product, &lock );
        mp = head;
        head = mp->next;
        pthread_mutex_unlock ( &lock );
        printf( "Consume %d tid: %d\n", mp->num, pthread_self());
        free( mp );
        sleep( rand() % 5 );
    }
}

void *producer ( void * p )
{
    msg * mp;
    for ( ;; ) {
        mp = malloc( sizeof(msg) );
        pthread_mutex_lock( &lock );
        mp->next = head;
        mp->num = rand() % 1000;
        head = mp;
        printf( "Produce %d tid: %d\n", mp->num, pthread_self());
        pthread_mutex_unlock( &lock );
        pthread_cond_signal( &has_product );
        sleep ( rand() % 5);
    }
}

int main(int argc, char *argv[] )
{
    pthread_t pid1, cid1;
    pthread_t pid2, cid2;
    srand(time(NULL));
    pthread_create( &pid1, NULL, producer, NULL);
    pthread_create( &pid2, NULL, producer, NULL);
    pthread_create( &cid1, NULL, consumer, NULL);
    pthread_create( &cid2, NULL, consumer, NULL);
    pthread_join( pid1, NULL );
    pthread_join( pid2, NULL );
    pthread_join( cid1, NULL );
    pthread_join( cid2, NULL );
    return 0;
}

image

其他并发问题

  • 一个线程是安全的，当且仅当被多个并发线程反复的调用时，它会一直产生正确的结果。
  • 四个不相交的线程不安全函数类以及应对措施：

不保护共享变量的函数——用P和V这样的同步操作保护共享变量

保持跨越多个调用的状态的函数——重写，不用任何static数据。

返回指向静态变量的指针的函数——①重写；②使用加锁-拷贝技术。

调用线程不安全函数的函数——参考之前三种

可重入性

  • 当它们被多个线程调用时，不会引用任何共享数据。
  • 显式可重入的：所有函数参数都是传值传递，没有指针，并且所有的数据引用都是本地的自动栈变量，没有引用静态或全剧变量。
  • 隐式可重入的：调用线程小心的传递指向非共享数据的指针。

竞争

  • 竞争发生的原因：一个程序的正确性依赖于一个线程要在另一个线程到达y点之前到达它的控制流中的x点。也就是说，程序员假定线程会按照某种特殊的轨迹穿过执行状态空间，忘了一条准则规定：线程化的程序必须对任何可行的轨迹线都正确工作。
  • 消除方法：动态的为每个整数ID分配一个独立的块，并且传递给线程例程一个指向这个块的指针

死锁

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

课后习题

  • 12.1 在下图中，并发服务器的第33行上，父进程关闭了已连接描述符后，子进程仍能够使用该描述符和客户端通信，为什么。
#include"csapp.h"
#include<stdlib.h>
#include<pthread.h>
void echo(int connfd);
void sigchld_handler(int sig)
{
while(waitpid(-1,0,WNOHANG)>0)
;
return;
}
int main(int argc,char **argv) 
{
int listenfd,connfd;
socklen_t clientlen;
struct sockaddr_storage clientaddr;
if(argc !=2) {
fprintf(stderr,"usage:%s <port>\n",argv[0]);
exit(0);
}
Signal(SIGCHLD,sigchld_handler);
listenfd=Open_listenfd(argv[1]);
while(1) {
clientlen=sizeof(struct sockaddr_storage);
connfd=Accept(listenfd, (SA *) &clientaddr, &clientlen);
if(Fork()==0) {
Close(listenfd);
echo(connfd);
Close(connfd);
exit(0);
}
Close(connfd);
}
}

解：当父进程派生子进程时，它得到一个已连接描述符的副本，并将相关文件表中的引用计数从1增加到2.当父进程关闭它的描述符副本时，引用计数就从2减少到1.因为内核不会关闭一个文件，知道文件表中它的引用计数值变为0，所以子进程这边的连接端将保持打开。

  • 12.2 如果我们要删除图12-5中关闭已连接描述符的第30行，从没有内存泄漏的角度来说，代码将仍然是正确的，为什么

解：当一个进程因为某种原因终止时，内核将关闭所有打开的描述符。因此，当子进程退出时，它的已连接文件描述符的副本也将被自动关闭。

  • 12.3 在Linux系统里，在标准输入上键入Ctrl+D表示EOF。图12-6中的程序阻塞在对select的调用上，如果你键入Ctrl+D会发生什么

解：如果一个从描述符中读一个字节的请求不会阻塞，那么这个描述符就准备好可以读了。假如EOF在一个描述符上为真，那么描述符也准备好可读了，因为读操作将立即返回一个零返回码，表示EOF。因此，键入Ctrl+D会导致select函数返回，准备好的集合中有描述符0。

  • 12.4 图12-8所示的服务器中，我们在每次调用select之前都立即小心地重新初始化pool.ready_set变量，为什么？

解：因为变量pool.read_set既作为输入参数，也作为输出参数，所以我们在每一次调用select之前都重新初始化它。在输入时，它包含读集合。在输出时，它包含准备好的集合。

  • 12.5在下图中基于进程的服务器中，我们在两个位置小心地关闭了已连接描述符：父进程和子进程。然而，在图2中，基于线程的服务器中，我们只在一个位置关闭了已连接描述符：对等线程，为什么？

解：因为线程运行在同一个进程中，它们都共享相同的描述符表。无论有多少线程使用这个已连接描述符，这个已连接描述符的文件表的引用计数都等于1.因此，当我们用完它时，一个close操作就足以释放于这个已连接描述符相关的内存资源了。

  • 12.6

解：

  • 12.7根据badcnt.c的指令顺序完成下表

  • 解：

  • 12.8 指出下列轨迹是否安全。
    A.H1，L1，U1，S1，H2，L2，U2，S2，T2，T1
    B.H2，L2，H1，L1，U1，S1，T1，U2，S2，T2
    C.H1，H2，L2，U2，S2，L1，U1，S1，T1，T2

解：A和C安全，B不安全。

  • 12.9

解：

  • 12.10下图所示的对第一类读者-写者问题的解答给予读者较高的优先级，但是从某种意义上说，这种优先级是很弱的，因为一个离开临界区的写者可能重启一个在等待的写者，而不是一个在等待的读者。描述一个场景，其中这种弱优先级会导致一群写者使得一个读者饥饿。

解：

  • 12.11

  • 12.12

解：ctime_ts函数不是可重入函数，因为每次调用都共享相同的由gethostbyname函数返回的static变量。然而他是安全的，因为对共享变量的访问被p和v操作是保护的，因此互斥。

  • 12.13 在下图所示代码中，我们可能想要在主线程中的第14行后立即释放已经分配的内存块，而不是在对等线程中释放它，这是个坏主意，为什么？

解：如果在第4行刚调用完pthread_create后就释放内存，这回引起一个竞争，这个竞争发生在主线程对free的调用和24的行的赋值语句之间。

  • 12.14
    A.在下图中，我们通过为每个整数ID分配一个独立的块来消除竞争。给出一个不调用malloc或者free函数的不同的方法。
    B.这种方法的利弊是什么？

A.另一种方法是直接传递整数i，而不是传递一个指向i的指针：

for(i=0;i<N;i++)
    Pthread_create(&tid[i],NULL,thread,(void*)i);

在线程例程中，我们将参数强制转换成一个int型变量，并将它赋值给myid;

int myid=(int)vargp;

B.优点是它通过消除对malloc和free的调用降低了开销。一个明显的缺点是，它假设指针至少和int一样大。即便这种假设对于所有得现代系统来说都为真，但是它对于那些过去遗留下来的或今后的系统来说可能就不为真了。

家庭作业

在第十二章中家庭作业有23道，其中有很多跟之前的练习类似，所以挑其中一部分来学习：

  • 12.17运行如下代码 A.没有任何输出，为什么？
    B.通过是用什么函数来改正这个错误呢？
#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<unistd.h>
#include<pthread.h>
void *thread(void *vargp);
int main(int argc, char **argv)
{
    pthread_t tid;
    int i,n;
    pthread_create(&tid,NULL,thread,NULL);
    exit(0);
}
void *thread(void *vargp)
{
    sleep(1);
    printf("hello world!\n");
    return NULL;
}

解：

A因为exit（0），使得线程在主线程中结束了，所以没有打印出任何字符。

B.使用

pthread_join

函数就可解决这个问题

  • 12.22检查对select函数的理解，修改下图所示服务器使得它在主服务器每次迭代中至多只会送一个文本：

解：在图上代码中while循环中增加一个

FD_AERO(&ready_set);

即可。

  • 12.25 并发echo服务器中，每个线程都调用echo_cnt函数，echo_cnt是安全的吗？可重入吗？
  • 解：是可重入的，因为，其中的参数connfd是局部非静态变量，对于每一个线程，都可以是不同的值。

下面来看一段代码：thread1.c

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int myglobal;
 void *thread_function(void *arg) {
  int i,j;
  for ( i=0; i<20; i++) {
    j=myglobal;
    j=j+1;
    printf(".");
    fflush(stdout);
    sleep(1);
    myglobal=j;
  }
  return NULL;
}
int main(void) {
  pthread_t mythread;
  int i;
  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("error creating thread.");
    abort();
  }
  for ( i=0; i<20; i++) {
    myglobal=myglobal+1;
    printf("o");
    fflush(stdout);
    sleep(1);
  }
  if ( pthread_join ( mythread, NULL ) ) {
    printf("error joining thread.");
    abort();
  }
  printf("\nmyglobal equals %d\n",myglobal);
  exit(0);
}

这个程序创建一个新线程。主线程和新线程都将全局变量 myglobal 加一 20 次。但是程序本身产生了某些意想不到的结果。编译代码请输入：

gcc thread1.c -o thread1 -lpthread

运行：

  • myglobal 从零开始，主线程和新线程各自对其进行了 20 次加一, 程序结束时 myglobal 值应当等于 40。由于 myglobal 输出结果为 21，为什么会出现这种情况？

  • 首先查看函数 thread_function()。将 myglobal 复制到局部变量 "j" ， 接着将 j 加一, 再睡眠一秒，然后才将新的 j 值复制到 myglobal。设想，如果主线程就在新线程将 myglobal 值复制给 j 后 立即将 myglobal 加一，会发生什么？当 thread_function() 将 j 的值写回 myglobal 时，就覆盖了主线程所做的修改。

当编写线程程序时，应避免产生这种无用的副作用，否则只会浪费时间。

使用 互斥对象(mutex)来解决该问题：
thread2.c

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
 void *thread_function(void *arg) {
  int i,j;
  for ( i=0; i<20; i++) {
    pthread_mutex_lock(&mymutex);
    j=myglobal;
    j=j+1;
    printf(".");
    fflush(stdout);
    sleep(1);
    myglobal=j;
    pthread_mutex_unlock(&mymutex);
  }
  return NULL;
}
int main(void) {
  pthread_t mythread;
  int i;
  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("error creating thread.");
    abort();
  }
  for ( i=0; i<20; i++) {
    pthread_mutex_lock(&mymutex);
    myglobal=myglobal+1;
    pthread_mutex_unlock(&mymutex);
    printf("o");
    fflush(stdout);
    sleep(1);
  }
  if ( pthread_join ( mythread, NULL ) ) {
    printf("error joining thread.");
    abort();
  }
  printf("\nmyglobal equals %d\n",myglobal);
  exit(0);
}

如果将这段代码与 前yige thread1.c想比较，就会注意到增加了

pthread_mutex_lock()

和

pthread_mutex_unlock()

函数调用。在线程程序中这些调用执行了不可或缺的功能。他们提供了一种 相互排斥的方法。两个线程不能同时对同一个互斥对象加锁。

互斥对象是这样工作的。如果线程 a 试图锁定一个互斥对象，而此时线程 b 已锁定了同一个互斥对象时，线程 a 就将进入睡眠状态。一旦线程 b 释放了互斥对象（通过 pthread_mutex_unlock() 调用），线程 a 就能够锁定这个互斥对象（换句话说，线程 a 就将从 pthread_mutex_lock() 函数调用中返回，同时互斥对象被锁定）。同样地，当线程 a 正锁定互斥对象时，如果线程 c 试图锁定互斥对象的话，线程 c 也将临时进入睡眠状态。对已锁定的互斥对象上调用 pthread_mutex_lock() 的所有线程都将进入睡眠状态，这些睡眠的线程将“排队”访问这个互斥对象。

  • 看 thread_function()，循环中一开始就锁定了互斥对象，最后才将它解锁。在这个示例程序中，mymutex 用来保护 myglobal 的值。仔细查看 thread_function()，加一代码把 myglobal 复制到一个局部变量，对局部变量加一，睡眠一秒钟，在这之后才把局部变量的值传回给 myglobal。不使用互斥对象时，即使主线程在 thread_function() 线程睡眠一秒钟期间内对 myglobal 加一，thread_function() 苏醒后也会覆盖主线程所加的值。使用互斥对象能够保证这种情形不会发生。使用互斥对象的新程序运行结果：

给你的结对学习搭档讲解你的总结并获取反馈

总结

在重新学习第十二章后，在第二遍学习的时候，感觉比第一遍要容易一些，也解决了第一次遇到的一些问题，但在第二遍学习的过程中，又会出现一些新的思考。在自己第一次读代码的时候，只能根据程序运行的结果，大致的猜测出每一句代码的含义，后来在看课本的时候总是会有恍然大悟的感觉，在运行代码后再学习课本内容，更能系统地理解知识点。比如看到pthread_create函数时，一开始我只知道这个函数会创建一个名为它的第一个参数的线程，而后我就应该跳到名为它的第三个参数的函数中继续执行代码；在看到课本后，我才知道这个过程叫做“主线程创建一个对等线程”，第一个参数为对等线程的名称，而pthread_join是在等待对等线程的终止。

posted @ 2017-12-17 17:27  短爪爪爪  阅读(202)  评论(1)  编辑  收藏  举报