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

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

本周考试错题总结

有关高速缓存的说法正确的是（）
- A . 高速缓存的容量可以用C=SEB 来计算
- B . 高速缓存容量为2048，高速缓存结构为（ 32 ，8，8，32）
- C . 直接映射高速缓存要：组选择、行匹配、字抽取
- D . 当程序访问大小为2的幂的数组时，直接映射高带缓存中常发生冲突不命中
解析：高速缓存容量为2048，高速缓存结构为（（32），8，8，32）

正确答案： A C D

有关缓存的说法，正确的是（）
- A . LRU策略指的是替换策略的缓存会选择最后被访问时间距现在最远的块
- B . 不同层之间以字节为传送单元来回复制
- C . 缓存不命时，决定哪个块是牺牲块由替换策略来控制
- D . 空缓存的不命中叫冲突不命中
解析：

B：
```
第k层和第k+1层之间以块大小为传送单元来回拷贝
```
D：
```
取数据时也分缓存命中和缓存不命中。缓存不命中也分为几大类
 1）强制不命中：即如果第k层的缓存是空的，那么一定就会不命中了。
 
 2）冲突不命中：假如发生了不命中之后，数据是会被缓存在第k层的，硬件通常将第k+1层中某个块限制在第k层中的某个子集中(采用映射)。
 
 3）容量不命中：当第k层的容量不足以缓存下需要缓存的数据时，就称为容量不命中。因此，空缓存的不命中属于强制不命中
```
正确答案： A C

下面说法正确的是（）
- A . CPU通过内存映射I/O向I/O设备发命令
- B . DMA传送不需要CPU的干涉
- C . SSD是一种基于闪存或Flash的存储技术
- D . 逻辑磁盘块的逻辑块号可以翻译成一个（盘面，磁道，扇区）三元组。
正确答案： A B C D

解析：

有关磁盘操作，说法正确的是（）
- A . 对磁盘扇区的访问时间包括三个部分中，传送时间最小。
- B . 磁盘以字节为单位读写数据
- C . 磁盘以扇区为单位读写数据
- D . 读写头总处于同一柱面
正确答案： A C

解析：读取数据的时候首先寻找的是数据所在的扇区，而数据是以字节为基本单位记录在各个扇区上，磁盘以扇区大小的块来读写数据。

有关磁盘，说法正确的是（）
- A . 磁盘的读取时间为毫秒级
- B . 每张磁盘有一个表面
- C . 表面由磁道组成
- D . 每个扇区的面积不同，包含的数据位的数量也不一样
正确答案： A C

解析：磁盘的记录方式有两种：1.旧式——非分区记录方式（不同磁道扇区数相同）;2.新式——分区记录方式（不同磁道扇区数不同）。旧式每个磁道所拥有的扇区数量都是一样的，且越往外面，扇区的面积越大，越往外面，转动的速度越快。每个扇区所能容纳的数据量是相同的，都是512字节，数据量需要平均分配在扇区面积的每个角落，所以外面扇区的数据密度低，里面扇区的速度密度高。

有关RAM的说法，正确的是（）
- A . SRAM和DRAM掉电后均无法保存里面的内容。
- B . DRAM将一个bit存在一个双稳态的存储单元中
- C . 一般来说，SRAM比DRAM快
- D . SRAM常用来作高速缓存
- E . DRAM将每一个bit存储为对一个电容充电
- F . SRAM需要不断刷新
- G . DRAM被组织为二维数组而不是线性数组
正确答案： A D E G

解析：SRAM将一个bit存在一个双稳态的存储单元中，而DRAM一般采用电容作为存储单元。DRAM每一个2ms要刷新1次避免数据丢失而SRAM是静态的不需要刷新。SDRAM在1个时钟周期内只传输1次数据，它是在时钟的上升期进行数据传输；而DDR内存则是1个时钟周期内传输两次数据，它能够在时钟的上升期和降落期各传输1次数据，因此称为双倍速率同步动态随机存储器。

有关计算机存储系统，下面说法正确的是（）
- A . 程序具有良好的局部性表现在倾向于从存储器层次结构中的较低层次处访问数据，这样节省时间
- B . 存储层次涉用不同容量，成本，访问时间的存储设备
- C . 存储层次设计基于局部性原理
- D . “存储山”是时间局部性和空间局部性的函数
正确答案： B C D

解析：程序具有良好的局部性表现在倾向于从存储器层次结构中的较高层次处访问数据，这样节省时间，层次越低，访问速度越慢。

课下作业： # 20155202张旭

20155202张旭 Linux下IPC机制

IPC机制定义
- 在linux下的多个进程间的通信机制叫做IPC(Inter-Process Communication)，它是多个进程之间相互沟通的一种方法。在linux下有多种进程间通信的方法：半双工管道、命名管道、消息队列、信号、信号量、共享内存、内存映射文件，套接字等等。使用这些机制可以为linux下的网络服务器开发提供灵活而又坚固的框架。
共享内存
- 共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，由IPC为进程创建的一个特殊地址范围，它将出现在该进程的地址空间（这里的地址空间具体是哪个地方？）中。其他进程可以将同一段共享内存连接到自己的地址空间中。所有进程都可以访问共享内存中的地址，就好像它们是malloc分配的一样。如果一个进程向共享内存中写入了数据，所做的改动将立刻被其他进程看到。
- 共享内存是IPC最快捷的方式，因为共享内存方式的通信没有中间过程，而管道、消息队列等方式则是需要将数据通过中间机制进行转换。共享内存方式直接将某段内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅映射到各进程的地址不同而已，因此不需要进行复制，可以直接使用此段空间。
- 注意：共享内存本身并没有同步机制，需要程序员自己控制。
共享内存的实例
```
int shmget(key_t key,size_t size,int shmflg);  //shmget函数用来创建一个新的共享内存段， 或者访问一个现有的共享内存段（不同进程只要key值相同即可访问同一共享内存段）。第一个参数key是ftok生成的键值，第二个参数size为共享内存的大小，第三个参数sem_flags是打开共享内存的方式。  
eg.int shmid = shmget(key, 1024, IPC_CREATE | IPC_EXCL | 0666);//第三个参数参考消息队列int msgget(key_t key,int msgflag);  
void *shmat(int shm_id,const void *shm_addr,int shmflg); //shmat函数通过shm_id将共享内存连接到进程的地址空间中。第二个参数可以由用户指定共享内存映射到进程空间的地址，shm_addr如果为0，则由内核试着查找一个未映射的区域。返回值为共享内存映射的地址。  
eg.char *shms = (char *)shmat(shmid, 0, 0);//shmid由shmget获得  
int shmdt(const void *shm_addr); //shmdt函数将共享内存从当前进程中分离。 参数为共享内存映射的地址。  
eg.shmdt(shms);  
int shmctl(int shm_id,int cmd,struct shmid_ds *buf);//shmctl函数是控制函数，使用方法和消息队列msgctl()函数调用完全类似。参数一shm_id是共享内存的句柄，cmd是向共享内存发送的命令，最后一个参数buf是向共享内存发送命令的参数。
```
代码练习：
```
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
typedef struct{
    char name[8];
    int age;
} people;
int main(int argc, char** argv)
{
    int shm_id,i;
    key_t key;
    char temp[8];
    people *p_map;
    char pathname[30] ;
 
    strcpy(pathname,"/tmp") ;
    key = ftok(pathname,0x03);
    if(key==-1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key=%d
",key) ;
    shm_id=shmget(key,4096,IPC_CREAT|IPC_EXCL|0600); 
    if(shm_id==-1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shm_id=%d
", shm_id) ;
    p_map=(people*)shmat(shm_id,NULL,0);
    memset(temp, 0x00, sizeof(temp)) ;
    strcpy(temp,"test") ;
    temp[4]='0';
    for(i = 0;i<3;i++)
    {
        temp[4]+=1;
        strncpy((p_map+i)->name,temp,5);
        (p_map+i)->age=0+i;
    }
    shmdt(p_map) ;
    return 0 ;
}

#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
typedef struct{
    char name[8];
    int age;
} people;
int main(int argc, char** argv)
{
    int shm_id,i;
    key_t key;
    people *p_map;
    char pathname[30] ;
 
    strcpy(pathname,"/tmp") ;
    key = ftok(pathname,0x03);
    if(key == -1)
    {
        perror("ftok error");
        return -1;
    }
    printf("key=%d
", key) ;
    shm_id = shmget(key,0, 0);   
    if(shm_id == -1)
    {
        perror("shmget error");
        return -1;
    }
    printf("shm_id=%d
", shm_id) ;
    p_map = (people*)shmat(shm_id,NULL,0);
    for(i = 0;i<3;i++)
    {
        printf( "name:%s
",(*(p_map+i)).name );
        printf( "age %d
",(*(p_map+i)).age );
    }
    if(shmdt(p_map) == -1)
    {
    
        perror("detach error");
        return -1;
    }
    return 0 ;
}
```
管道（PIPE）
- 管道实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端将其读取出来。
  管道的特点：
1. 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
2. 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。比如fork或exec创建的新进程，在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。当父进程与使用fork创建的子进程直接通信时，发送数据的进程关闭读端，接受数据的进程关闭写端。
3. 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
4. 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
代码练习：
```
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<wait.h>
#include<sys/types.h>
int main(int argc ,char *argv[])
{
 int pipefd[2],result;
 char buf[1024];
 int flag=0;
 pid_t pid;
 result= pipe(pipefd);//创建一个管道
 if(result==-1){
  perror("pipe error:");
  exit(EXIT_FAILURE);
 }
 pid=fork();//创建一个子进程
 if(pid==-1)
 {
  perror("fork  error:");
  exit(EXIT_FAILURE);
 }
 else if(pid==0){
  if((close(pipefd[1]))==-1)//close write only read
  {
   perror("close write  error:");
   exit(EXIT_FAILURE);
  }
  while(1){ //循环读取数据
   read(pipefd[0],buf,1024);//最多读取1024个字节
   printf("read from pipe :  %s
",buf);
   if(strcmp(buf,"quit")==0){// if 读取到的字符串是exit 这是 
                    //父进程会接受到一个终止进程的信号，父进程会回收子进程的资                   // 源等
   exit(EXIT_SUCCESS);
   }    
  }     
 }else{
  //close read only write
  if((close(pipefd[0]))==-1){
   perror("close read error:");
   exit(EXIT_FAILURE);
  } 
  while(1)//循环写入内容
  { 
   waitpid(pid,NULL,WNOHANG);//等待子进程退出
   if(flag==1) 
    exit(0);
   scanf("%s",buf);
   write(pipefd[1],buf,strlen(buf)+1);//具体写多少个字节
   if(strcmp(buf,"quit")==0){ 
    flag=1;
    sleep(1);//让子进程完全退出。
   }
  }
 }
 return 1;
}
```
管道实例：
```
#include <unistd.h> 
int pipe(int file_descriptor[2]);//建立管道，该函数在数组上填上两个新的文件描述符后返回0，失败返回-1。
eg.int fd[2]
int result = pipe(fd);
```
命名管道（FIFO）
- 命名管道是一种特殊类型的文件，它在系统中以文件形式存在。这样克服了管道的弊端，他可以允许没有亲缘关系的进程间通信。具体操作方法只要创建了一个命名管道然后就可以使用open、read、write等系统调用来操作。创建可以手工创建或者程序中创建。
命名管道实例：
```
#include <unistd.h>  
#include <stdlib.h>  
#include <fcntl.h>  
#include <limits.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <stdio.h>  
#include <string.h>  
  
int main()  
{  
    const char *fifo_name = "/tmp/my_fifo";  
    int pipe_fd = -1;  
    int data_fd = -1;  
    int res = 0;  
    const int open_mode = O_WRONLY;  
    int bytes_sent = 0;  
    char buffer[PIPE_BUF + 1];  
  
    if(access(fifo_name, F_OK) == -1)  
    {  
        //管道文件不存在  
        //创建命名管道  
        res = mkfifo(fifo_name, 0777);  
        if(res != 0)  
        {  
            fprintf(stderr, "Could not create fifo %s
", fifo_name);  
            exit(EXIT_FAILURE);  
        }  
    }  
  
    printf("Process %d opening FIFO O_WRONLY
", getpid());  
    //以只写阻塞方式打开FIFO文件，以只读方式打开数据文件  
    pipe_fd = open(fifo_name, open_mode);  
    data_fd = open("Data.txt", O_RDONLY);  
    printf("Process %d result %d
", getpid(), pipe_fd);  
  
    if(pipe_fd != -1)  
    {  
        int bytes_read = 0;  
        //向数据文件读取数据  
        bytes_read = read(data_fd, buffer, PIPE_BUF);  
        buffer[bytes_read] = '';  
        while(bytes_read > 0)  
        {  
            //向FIFO文件写数据  
            res = write(pipe_fd, buffer, bytes_read);  
            if(res == -1)  
            {  
                fprintf(stderr, "Write error on pipe
");  
                exit(EXIT_FAILURE);  
            }  
            //累加写的字节数，并继续读取数据  
            bytes_sent += res;  
            bytes_read = read(data_fd, buffer, PIPE_BUF);  
            buffer[bytes_read] = '';  
        }  
        close(pipe_fd);  
        close(data_fd);  
    }  
    else  
        exit(EXIT_FAILURE);  
  
    printf("Process %d finished
", getpid());  
    exit(EXIT_SUCCESS);  
}
```
```
#include <sys/types.h>   
#include <sys/stat.h>   
int mkfifo(const char *filename,mode_t mode); //建立一个名字为filename的命名管道，参数mode为该文件的权限（mode%~umask），若成功则返回0，否则返回-1，错误原因存于errno中。  
eg.mkfifo( "/tmp/cmd_pipe", S_IFIFO | 0666 );
```
```
int mknod(const char *path, mode_t mode, dev_t dev); //第一个参数表示你要创建的文件的名称，第二个参数表示文件类型，第三个参数表示该文件对应的设备文件的设备号。只有当文件类型为 S_IFCHR 或 S_IFBLK 的时候该文件才有设备号，创建普通文件时传入0即可。  
eg.mknod(FIFO_FILE,S_IFIFO|0666,0);
```
管道和命名管道的区别：
- 对于命名管道FIFO来说，IO操作和普通管道IO操作基本一样，但是两者有一个主要的区别，在命名管道中，管道可以是事先已经创建好的，比如我们在命令行下执行
```
mkfifo myfifo
```
```
#include <unistd.h>  
#include <stdlib.h>  
#include <stdio.h>  
#include <fcntl.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <limits.h>  
#include <string.h>  
  
int main()  
{  
    const char *fifo_name = "/tmp/my_fifo";  
    int pipe_fd = -1;  
    int data_fd = -1;  
    int res = 0;  
    int open_mode = O_RDONLY;  
    char buffer[PIPE_BUF + 1];  
    int bytes_read = 0;  
    int bytes_write = 0;  
    //清空缓冲数组  
    memset(buffer, '', sizeof(buffer));  
  
    printf("Process %d opening FIFO O_RDONLY
", getpid());  
    //以只读阻塞方式打开管道文件，注意与fifowrite.c文件中的FIFO同名  
    pipe_fd = open(fifo_name, open_mode);  
    //以只写方式创建保存数据的文件  
    data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);  
    printf("Process %d result %d
",getpid(), pipe_fd);  
  
    if(pipe_fd != -1)  
    {  
        do  
        {  
            //读取FIFO中的数据，并把它保存在文件DataFormFIFO.txt文件中  
            res = read(pipe_fd, buffer, PIPE_BUF);  
            bytes_write = write(data_fd, buffer, res);  
            bytes_read += res;  
        }while(res > 0);  
        close(pipe_fd);  
        close(data_fd);  
    }  
    else  
        exit(EXIT_FAILURE);  
  
    printf("Process %d finished, %d bytes read
", getpid(), bytes_read);  
    exit(EXIT_SUCCESS);  
}
```
就是创建一个命名通道，我们必须用open函数来显示地建立连接到管道的通道，而在管道中，管道已经在主进程里创建好了，然后在fork时直接复制相关数据或者是用exec创建的新进程时把管道的文件描述符当参数传递进去。
- 一般来说FIFO和PIPE一样总是处于阻塞状态。也就是说如果命名管道FIFO打开时设置了读权限，则读进程将一直阻塞，一直到其他进程打开该FIFO并向管道写入数据。这个阻塞动作反过来也是成立的。如果不希望命名管道操作的时候发生阻塞，可以在open的时候使用O_NONBLOCK标志，以关闭默认的阻塞操作。
信号（signal）
- 信号机制是unix系统中最为古老的进程之间的通信机制，用于一个或几个进程之间传递异步信号。信号可以有各种异步事件产生，比如键盘中断等。shell也可以使用信号将作业控制命令传递给它的子进程。
信号实例

int kill(pid_t pid,int sig); //kill函数向进程号为pid的进程发送信号，信号值为sig。当pid为0时，向当前系统的所有进程发送信号sig。
int raise(int sig);//向当前进程中自举一个信号sig, 即向当前进程发送信号。

include <unistd.h>

unsigned int alarm(unsigned int seconds); //alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数seconds为0,则之前设置的闹钟会被取消,并将剩下的时间返回。使用alarm函数的时候要注意alarm函数的覆盖性，即在一个进程中采用一次alarm函数则该进程之前的alarm函数将失效。
int pause(void); //使调用进程（或线程）睡眠状态，直到接收到信号，要么终止，或导致它调用一个信号捕获函数。

##### 代码：
```
#include <stdio.h>   
#include <sys/types.h>   
#include <stdlib.h>    
#include <signal.h>    
    

int main()    
{   
    char buffer[100];    
  
    struct sigaction act;  
  
    if(sigaction(SIGINT,&act, NULL) == -1)  
    {  
        printf("sigaction error exit now
");  
        exit(0);  
    }  
  
    while(1)  
    {  
        fgets(buffer,sizeof(buffer),stdin);  
        printf("%s
",buffer);  
    }  
  
    return 0;    
}
```
消息队列
- 消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用IPC标识符唯一地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。每个消息队列中的消息，又构成一个独立的链表。
  消息队列克服了信号承载信息量少，管道只能承载无格式字符流。
消息队列的本质
- Linux的消息队列(queue)实质上是一个链表，它有消息队列标识符(queue ID)。 msgget创建一个新队列或打开一个存在的队列；msgsnd向队列末端添加一条新消息；msgrcv从队列中取消息，取消息是不一定遵循先进先出的，也可以按消息的类型字段取消息。
消息队列与命名管道的比较
- 消息队列跟命名管道有不少的相同之处，通过与命名管道一样，消息队列进行通信的进程可以是不相关的进程，同时它们都是通过发送和接收的方式来传递数据的。在命名管道中，发送数据用write，接收数据用read，则在消息队列中，发送数据用msgsnd，接收数据用msgrcv。而且它们对每个数据都有一个最大长度的限制。
- 与命名管道相比，消息队列的优势在于，1、消息队列也可以独立于发送和接收进程而存在，从而消除了在同步命名管道的打开和关闭时可能产生的困难。2、同时通过发送消息还可以避免命名管道的同步和阻塞问题，不需要由进程自己来提供同步方法。3、接收程序可以通过消息类型有选择地接收数据，而不是像命名管道中那样，只能默认地接收。
- 消息队列头文件：
```
#include <sys/types.h> 
#include <sys/stat.h> 
#include <sys/msg.h>
```
- 1、消息缓冲区结构：
```
struct msgbuf{
    long mtype;
    char mtext[1];//柔性数组
}
```
- 在结构中有两个成员，mtype为消息类型，用户可以给某个消息设定一个类型，可以在消息队列中正确地发送和接受自己的消息。mtext为消息数据，采用柔性数组，用户可以重新定义msgbuf结构。例如：
```
struct msgbuf{  
    long mtype;  
    char mtext[1];//柔性数组  
}
```
- 当然用户不可随意定义msgbuf结构，因为在linux中消息的大小是有限制的，在linux/msg.h中定义如下：
define MSGMAX 8192

消息总的大小不能超过8192个字节，包括mtype成员（4个字节）。
- 2、ipc_perm内核数据结构：结构体ipc_perm保存着消息队列的一些重要的信息，比如说消息队列关联的键值，消息队列的用户id组id等。它定义在头文件linux/ipc.h中。
```
struct ipc_perm{  
  key_t key;  
  uid_t uid;  
  gid_t gid;  
  .......  
};
```
代码：
```
#include<stdio.h>
#include<stdlib.h>
#include<sys/msg.h>
#include<string.h>
#include<unistd.h>
#define MAX_TEXT 1024
#define MSG_SIZE 512
struct msg_st{
    long int msg_type; //消息类型
    char text[MAX_TEXT];//消息内容
};
int main()
{
    struct msg_st data;
    char buf[MSG_SIZE];
    int msgid=msgget((key_t)2456,0666|IPC_CREAT);
    if(msgid==-1){
        perror("msgget");
        exit(1);
    }
    while(1){
        printf("接收:");
        if(msgrcv(msgid,(void*)&data,MAX_TEXT,1,0)==-1){
            perror("msgrcv");
            exit(2);
        }
        printf("%s
",data.text);
    }
    return 0;
}
```
```
#include<stdio.h>
#include<sys/ipc.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/msg.h>
#include<unistd.h>
#include<string.h>
#define MAX_TEXT 512
#define MSG_SIZE 512
struct msg_st
{
    long int msg_type;  //消息类型
    char text[MAX_TEXT];//消息内容
};
int main()
{
    struct msg_st data;
    char buf[MSG_SIZE];
    //创建消息队列
    int msgid=msgget((key_t)2456,0666|IPC_CREAT);
    if(msgid==-1)
    {
        perror("msgget");
        exit(1);
    }
    printf("消息队列创建成功
");
    //发送消息
    while(1)
    {
        //从键盘输入发送的消息
        printf("发送：");
        fgets(buf,MSG_SIZE,stdin);
        data.msg_type=1;
        strcpy(data.text,buf);
        //将消息发送到消息队列
        if(msgsnd(msgid,(void*)&data,MAX_TEXT,0)==-1){
            perror("msgsnd");
            exit(1);
        }   
    }
    return 0;
}
```
消息队列、信号量以及共享内存的相似之处：
- 它们被统称为XSI IPC，它们在内核中有相似的IPC结构（消息队列的msgid_ds，信号量的semid_ds，共享内存的shmid_ds），而且都用一个非负整数的标识符加以引用（消息队列的msg_id，信号量的sem_id，共享内存的shm_id，分别通过msgget、semget以及shmget获得），标志符是IPC对象的内部名，每个IPC对象都有一个键（key_t key）相关联，将这个键作为该对象的外部名。
- 参考博客：linux基础——linux进程间通信（IPC）机制总结
相关阅读:
TextView 内容设置成上下滑动和代码设置字体颜色
 Android提供了4种在其他线程中访问UI线程的方法
 Android 左右滑屏效果
 【自定义控件】 GridView
【动画】【特效】activity跳转华丽的过渡效果（转载）
Android获取设备型号、SDK版本及其系统版本
 【JSON】数据解析
 Android中文API集合
 【AssetManager】的使用与资源预加载
 @property（nonatomic,retain)
原文地址：https://www.cnblogs.com/zx20155202/p/7892050.html

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

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

本周考试错题总结

有关高速缓存的说法正确的是（）

解析：高速缓存容量为2048，高速缓存结构为（（32），8，8，32）

正确答案： A C D

有关缓存的说法，正确的是（）

解析：

正确答案： A C

下面说法正确的是（）

正确答案： A B C D

解析：

有关磁盘操作，说法正确的是（）

正确答案： A C

解析：读取数据的时候首先寻找的是数据所在的扇区，而数据是以字节为基本单位记录在各个扇区上，磁盘以扇区大小的块来读写数据。

有关磁盘，说法正确的是（）

正确答案： A C

有关RAM的说法，正确的是（）

正确答案： A D E G

有关计算机存储系统，下面说法正确的是（）

正确答案： B C D

解析：程序具有良好的局部性表现在倾向于从存储器层次结构中的较高层次处访问数据，这样节省时间，层次越低，访问速度越慢。

课下作业： # 20155202张旭

20155202张旭 Linux下IPC机制

IPC机制定义

共享内存

共享内存的实例

管道 （PIPE）

管道实例：

命名管道（FIFO）

命名管道实例：

管道和命名管道的区别：

信号 （signal）

信号实例

include <unistd.h>

##### 代码：

消息队列

消息队列的本质

消息队列与命名管道的比较

define MSGMAX 8192

代码：

消息队列、信号量以及共享内存的相似之处：

管道（PIPE）

信号（signal）