Linux并发编程实验(线程、进程)
Linux并发编程实验多线程、多进程编程
一．实验目的和要求
二、实验内容
三、实验结果与分析
1、进程实验
（1）分别创立4个C文件，get.c、copy.c、put.c以及main.c分别实验读入，拷贝，输出，及前三个函数的调用；
（2）定义三个缓冲区，其中一个记录对各项操作的选择，另外两个用来传输拷贝文件
内容，相当于图中的缓冲区s和缓冲区t；
（3）并发执行时定义了4个信号灯，分别用来控制缓冲区s是否有内容，缓冲区s是否空，缓冲区t是否有内容，缓冲区t是否为空；顺序执行时定义了三个信号灯，让get、copy、put分别其按顺序依次执行。
（4）创建三个进程分别实现get、copy、put功能；
（5）并发时原理如下
If(f不为空)
｛
get(s,f);
while（誊抄未完成）
｛
t=s；
cobegin
put(t,g);
get(s,f);
coend;
｝
｝
（6）顺序执行时原理如下：
while（f不为空）
｛
input;
output;
｝
（7）创建一个字符文档如下，大小为42.4KB，内容为一连串的字符
此时文件比较小用并发和顺序所得执行结果如下
由此可知当文件很小时，并发执行和顺序执行比本感觉不出差距。
（8）创建一个一个较大的f.txt文档，大小为113.5KB，内容为一连串字符，如下：
此时文件较大，并发执行和顺序执行的程序运行结果如下所示：
此时才能看出两者之间有细小的差别，顺序执行效率小于并发执行的效率！但还是可见差距非常不明显！
（9）分析：对于进程而言，顺序执行和并发执行之间的差距并不是那么明显，尤其是在拷贝文件较小时，基本感觉不出差距，只有在拷贝文件很大时才能有感觉到明显的差距。
2、线程实验
（1）实验原理与进程一致，只是这次用的是一个thread。C文件，内部有4个函数分别为get、copy、put、main来实现全部功能。并且创建的为3个线程。
（2）创建一个f.txt文件，大小为113.5KB,内容为一串连续字符，如下所示
并发和顺序的执行结果如下所示：
并发执行的结果为4.83秒，而顺序执行在两分钟后还是没有完成，用ctrl+C打断，可见当要拷贝的文件很大时，线程的并发和顺序执行之间的差距是非常明显的！
（3）创建一个较小的f.txt文件,大小为7.6KB，内容为一连串的字符，如下所示:
此时的运行结果如下所示：
可见，当拷贝的文件较小时，线程的顺序与并发执行指尖的差距也会变小。
（4）分析：线程而言，越是大的文件拷贝，顺序执行与并发执行的差距就越明显，即使文件很小，也能感到一定的差距
3、进程与线程的对比分析
进程与线程相比，分得的资源更多，因此执行起来的速度相对线程要快很多，因此，即使是拷贝很大的文件，对于并发执行和顺序执行两者的差距也不是那么显著，对于小文件就更是基本感觉不到差距；而线程不一样，分得的资源相比进程少很多，执行速度相对较慢，即使是小文件的拷贝也能感觉到两者拷贝速度的差距，对于大文件的拷贝就更是如此，越是大的文件顺序执行速度慢的太多，甚至无法在一定时间内完成。
四、参考文献
庞丽萍《操作系统原理》（第四版）华中科技大学出版社
参考文档（PDF格式）
Concurrentcopy
Multiprocess Programming Guide
Multithreaded Programming Guide
五、实验感想
老实说，这是一次规模相当庞大的实验，不仅难度大，而且对于线程进程的编程知识本身可谓一窍不通，有一段漫长的学习过程。但是经过几个礼拜的努力，还是圆满的将这份实验完成，对于这个结果本人还是相当满意的！
首先是对于线程和进程的编程了解说起，虽然有老师给的资料，知道了那些函数大概要怎么用，但是对于写程序来说还是太吃力了，因此还是在网上找了一些关于进程线程编程的文件，了解基本程序模式，然后靠感觉来写，过程相对来说是有点凄惨的，但是在不懈的努力下还是有了大概的样子，对于进程的共享内存方面看着确实头痛，完全不理解那样的作用，但还是硬着头皮仿写，并且迫使自己去理解它。在了解了编程中信号量的使用后才正式对自己的程序进行修改，但是也出现过很多问题，譬如因为P/V操作的计算和使用失误导致死循环或者挂起之类的，改的确实心力交瘁。线程对于进程而言相对简单些，也因为我是先做完进程实验再着手线程，因此在了解线程的基本格式后也在较短的时间内将其完成。出过的一点小问题就在于在过程中同时使用了信号灯和锁，导致了挂起，这个再后来觉得确实没必要，因为这两样都可以实现互斥，后来也把锁去掉了，直接信号灯来控制。对于进程编程，虽然我完成了，但是很多地方还是无法理解，实现了get、copy、put，但是main函数老是出问题，信号灯的初始化，进程建立都是一步一步的修改，对于缓冲区特殊键和共享设置至今也不是很懂为什么那样做，只能按照一些样例的格式模仿来写……总之这次实验给我的感觉是难度不小于一场课设，有太多需要自学的东西，需要花时间去理解，但也因为如此，经过这场实验我也觉的我学到了很多，也因为这学期之前从未接触过linux编程，也让我在知识面上有了很大程度的提高，也希望在以后有时间时能更多的接触这方面的知识，相信这对于以后也是大有帮助的。
六、源代码
1、并发进程
（1）Main.c
#include
#include
#include
#include
#include
#include
#include
#include
#include
union semun{
int sign;
struct sedid_ds *buf;
unsigned *array;
};
int semid;
int buf1,buf2,buf3;
char *S;
char *op;
char * T;
pid_t p1,p2,p3;
void P(int semid,int num) {
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1); }
void V(int semid,int num) {
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int grgc,char* argv[])
{
clock_t start,end;
start = clock();
union semun semopts;
semid=semget(200,4,IPC_CREAT|0666);
semopts.sign=1;
semctl(semid,0,SETVAL,semopts);
semopts.sign=0;
semctl(semid,1,SETVAL,semopts);
semopts.sign=1;
semctl(semid,2,SETVAL,semopts);
semopts.sign=0;
semctl(semid,3,SETVAL,semopts);
buf1=shmget(231,1024,IPC_CREAT|0666);
buf2=shmget(232,1024,IPC_CREAT|0666);
buf3=shmget(233,1024,IPC_CREAT|0666);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
if((p1=fork())==0)
execv("./get",NULL);
if((p2=fork())==0)
execv("./copy",NULL);
if((p3=fork())==0)
execv("./put",NULL);
while(*op!='p')
sleep(1);
shmctl(buf1,IPC_RMID,0);
shmctl(buf2,IPC_RMID,0);
shmctl(buf3,IPC_RMID,0);
semctl(semid,0,IPC_RMID,0);
semctl(semid,1,IPC_RMID,0);
semctl(semid,2,IPC_RMID,0);
semctl(semid,3,IPC_RMID,0);
end = clock();
printf("Run time: %lf S",(double)(end-start)/CLOCKS_PER_SEC);
printf("\n");
return 0;
}
（2）Get.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char* argv[])
{
FILE *in1;
int semid;
int buf1,buf2;
char *S;
char *op;
semid=semget(200,0,0666);
buf1=shmget(231,0,0666);
buf2=shmget(232,0,0666);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
if((in1=fopen("./f.txt","rb"))==NULL)
exit(-1);
while(!feof(in1))
{
P(semid,0);
if((fgets(S,50,in1))==NULL)
{
*op='g';
V(semid,1);
break;
}
V(semid,1);
}
fclose(in1);
}
（3）Copy.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char *argv[])
{
int semid;
int buf1,buf2,buf3;
char *op;
char *S;
char *T;
semid=semget(200,0,0666);
buf1=shmget(231,0,0666);
buf2=shmget(232,0,0666);
buf3=shmget(233,0,0666);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char *)shmat(buf2,NULL,0666);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
while(1)
{
P(semid,1);
P(semid,2);
if(*op=='g')
{
*op='c';
V(semid,0);
V(semid,3);
return 0;
}
strcpy(T,S);
V(semid,0);
V(semid,3);
}
｝
（4）Put.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char *argv[])
{
int semid;
int buf2,buf3;
char *T;
char *op;
FILE *out1;
semid=semget(200,0,0666);
buf2=shmget(232,0,0666);
buf3=shmget(233,0,0666);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
if((out1=fopen("./g.txt","wb"))==NULL)
exit(-1);
while(1)
{
P(semid,3);
if(*op=='c'){
V(semid,2);
break;
}
fputs(T,out1);
V(semid,2);
}
*op='p';
fclose(out1);
}
2、顺序进程
（1）顺序main.c
#include
#include
#include
#include
#include
#include
#include
#include
#include
union semun{
int sign;
struct sedid_ds *buf;
unsigned *array;
};
int semid;
int buf1,buf2,buf3;
char *S;
char *op;
char * T;
pid_t p1,p2,p3;
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int grgc,char* argv[])
{
clock_t start,end;
start = clock();
union semun semopts;
semid=semget(200,4,IPC_CREAT|0666);
semopts.sign=0;
semctl(semid,1,SETVAL,semopts);
semopts.sign=0;
semctl(semid,2,SETVAL,semopts);
semopts.sign=1;
semctl(semid,3,SETVAL,semopts);
buf1=shmget(231,1024,IPC_CREAT|0666);
buf2=shmget(232,1024,IPC_CREAT|0666);
buf3=shmget(233,1024,IPC_CREAT|0666);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
if((p1=fork())==0)
execv("./get",NULL);
if((p2=fork())==0)
execv("./copy",NULL);
if((p3=fork())==0)
execv("./put",NULL);
while(*op!='p')
sleep(1);
shmctl(buf1,IPC_RMID,0);
shmctl(buf2,IPC_RMID,0);
shmctl(buf3,IPC_RMID,0);
semctl(semid,1,IPC_RMID,0);
semctl(semid,2,IPC_RMID,0);
semctl(semid,3,IPC_RMID,0);
end = clock();
printf("Run time: %lf S",(double)(end-start)/CLOCKS_PER_SEC);
printf("\n");
return 0;
}
（2）Get.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char* argv[])
{
FILE *in1;
int semid;
int buf1,buf2;
char *S;
char *op;
semid=semget(200,0,0666);
buf1=shmget(231,0,0666);
buf2=shmget(232,0,0666);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
if((in1=fopen("./f.txt","rb"))==NULL)
exit(-1);
while(!feof(in1))
{
P(semid,3);
if((fgets(S,50,in1))==NULL)
{
*op='g';
V(semid,1);
break;
}
V(semid,1);
}
fclose(in1);
}
（3）Copy.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char *argv[])
{
int semid;
int buf1,buf2,buf3;
char *op;
char *S;
char *T;
semid=semget(200,0,0666);
buf1=shmget(231,0,0666);
buf2=shmget(232,0,0666);
buf3=shmget(233,0,0666);
S=(char*)shmat(buf1,NULL,SHM_R|SHM_W);
op=(char *)shmat(buf2,NULL,0666);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
while(1)
{
P(semid,1);
if(*op=='g')
{
*op='c';
V(semid,2);
return 0;
}
strcpy(T,S);
V(semid,2);
}
}
（4）Put.c
#include
#include
#include
#include
#include
#include
#include
#include
void P(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=-1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
void V(int semid,int num)
{
struct sembuf signal;
signal.sem_num=num;
signal.sem_op=1;
signal.sem_flg=0;
semop(semid,&signal,1);
}
int main(int argc,char *argv[])
{
int semid;
int buf2,buf3;
char *T;
char *op;
FILE *out1;
semid=semget(200,0,0666);
buf2=shmget(232,0,0666);
buf3=shmget(233,0,0666);
op=(char*)shmat(buf2,NULL,SHM_R|SHM_W);
T=(char*)shmat(buf3,NULL,SHM_R|SHM_W);
if((out1=fopen("./g.txt","wb"))==NULL)
exit(-1);
while(1)
{
P(semid,2);
if(*op=='c'){
V(semid,3);
break;
}
fputs(T,out1);
V(semid,3);
}
*op='p';
fclose(out1);
}
3、并发线程
#include
#include
#include
#include
#include
#include
void get();
void copy();
void put();
sem_t s_e,s_f,t_e,t_f;
pthread_mutex_t s,t;
int end_copy=1,end_put=1;
char *buf1,*buf2;
void main()
{
clock_t start,end;
start = clock();
pthread_t t1,t2,t3;
sem_init(&s_f,0,0);
sem_init(&t_f,0,0);
sem_init(&s_e,0,1);
sem_init(&t_e,0,1);
pthread_create(&t1,NULL,(void *)get,NULL);
pthread_create(&t2,NULL,(void *)copy,NULL);
pthread_create(&t3,NULL,(void *)put,NULL);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_join(t3,NULL);
end = clock();
printf("Run time: %lf S",(double)(end-start)/CLOCKS_PER_SEC); }
void get()
{
int i;
char ch;
FILE *fp;
buf1=(char *)malloc((sizeof(char))*20);
if((fp=fopen("./f.txt","rb"))==NULL)
exit(-1);
while(!feof(fp))
{
sem_wait(&s_e);
if(fgets(buf1,5,fp)==NULL)
break;
sem_post(&s_f);
}
sem_post(&s_f);
fclose(fp);
end_copy=0,end_put=0;
}
void copy()
{
int i;
实验七：Linux多线程编程(实验分析报告)
实验七：Linux多线程编程(实验报告)
————————————————————————————————作者：————————————————————————————————日期：
实验七：Linux多线程编程（4课时） 实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。 实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 1 多线程概念 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。 使用多线程的理由之二是线程间方便的通信机制。同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。2多线程编程函数 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。 函数pthread_create用来创建一个线程，它的原型为： extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join(pthread_t th, void **thread_return); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。 函数pthread_exit的函数原型为： extern void pthread_exit(void *retval); 唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。 3 修改线程的属性 线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。 设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。 另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。 4 线程的数据处理
基于嵌入式Linux多线程聊天系统的设计与实现
基于嵌入式Linux多线程聊天系统的设计与实现 学生姓名王宣达 学号 S2******* 所在系（院）电子信息工程系 专业名称电路与系统年级 2009级 2011年8月3日
中文摘要
外文摘要
目录 1．引言 (1) 2．Linux多线程聊天系统的设计思想 (3) 2.1 聊天系统中服务器的设计思想 (3) 2.2 聊天系统中客户端的设计思想 (3) 3. Linux多线程聊天系统的实现过程 (5) 3.1 多线程聊天系统中服务器端的实现过程 (5) 3.2 多线程聊天系统中客户端的实现过程 (7) 4.Linux多线程系统设计中出现的问题和解决的方法 (12) 4.1 多线程中资源的释放问题 (12) 4.2 (12) 参考文献 (12)
1．引言 在80年代中期，线程技术就应用到了操作系统中，那时在一个进程中只允许有一个线程，这样多线程就意味着多进程，虽然实现了多任务，但是资源消耗还是非常可观的。而到现在，多线程技术已经被许多操作系统所支持，有Windows/NT，还有Linux。 多线程和进程相比有两点优势： 1.它是一种消耗资源非常少的多任务操作方式。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种消耗非常大的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，这样创建一个线程所占用的空间远远小于创建一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。当然，随着系统的不同，这个差距也不不同。 2.线程间比进程间的通信机制更为便利。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，这时就要用到互斥锁机制来保证线程间的同步。 所以在本文的多线程聊天程序的设计中，采用多线程的方式设计系统更为适宜。其中，系统中用到的操作主要是：线程操作，设置互斥锁。其中，线程操作包括：线程创建，退出，。设置互斥锁包括：创建互斥锁，加锁和解锁。 但是，要实现网络聊天，系统中还要用到linux下的网络编程。 Linux下的网络编程通过socket接口实现。socket 是一种特殊的I/O，可以实现网络上的通信机制。Socket也是一种文件描述符。它具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket
基于linux的socket多线程通信
1、网络中进程之间如何通信？ 本地的进程间通信（IPC）有很多种方式，但可以总结为下面4类： ?消息传递（管道、FIFO、消息队列） ?同步（互斥量、条件变量、读写锁、文件和写记录 锁、信号量） ?共享内存（匿名的和具名的） ?远程过程调用（Solaris门和Sun RPC） 但这些都不是本文的主题！我们要讨论的是网络中进程之间如何通信？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的―ip地址‖可以唯一标识网络中的主机，而传输层的―协议+端口‖可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。 使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说―一切皆socket‖。 2、什么是Socket？ 上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是―一切皆文件‖，都可以用―打开open –> 读写write/read –> 关闭close‖模式来操作。我的理解就是Socket就是该模式的一个实现，socket 即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。 socket一词的起源 在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的，撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载，Croker写道：―命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端，而一个连接可完全由一对套接字接口规定。‖计算机历史博物馆补充道：―这比BSD的套接字接口定义早了大约12年。‖ 3、socket的基本操作 既然socket是―open—write/read—close‖模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。 3.1、socket()函数 int socket(int domain, int type, int protocol); socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。 正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket 函数的三个参数分别为：
实验二-Linux进程、线程及编程
实验二Linux进程、线程及编程实验 一、实验目的 1、通过编写一个完整的守护进程，掌握守护进程编写和调试的方法 2、进一步熟悉如何编写多进程程序 二、实验环境 硬件：PC机一台，JXARM9－2410教学实验平台。 软件：Windows98/XP/2000系统，虚拟机环境下的Linux系统。 三、预备知识 1、fork() fork()函数用于从已存在的进程中创建一个新进程。新进程称为子进程，而原进程称为父进程。使用fork()函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间，包括进程上下文、代码段、进程堆栈、存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制和控制终端等，而子进程所独有的只有它的进程号、资源使用和计时器等 2、exit()和_exit()的区别 _exit()函数的作用最为简单：直接使进程停止运行，清除其使用的存空间，并销毁其在核中的各种数据结构； exit()函数则在这些基础上作了一些包装，在执行退出之前加了若干道工序。 exit()函数在调用exit系统调用之前要检查文件的打开情况，把文件缓冲区中的容写回文件，就是图中的"清理I/O缓冲"一项。 3、wait()和waitpid() wait()函数是用于使父进程（也就是调用wait()的进程）阻塞，直到一个子进程结束或者该进程接到了一个指定的信号为止。如果该父进程没有子进程或者他的子进程已经结束，则wait()就会立即返回。 四、实验容 在该实验中，读者首先创建一个子进程1（守护进程），然后在该子进程中新建一个子进程2，该子进程2暂停10s，然后自动退出，并由子进程1收集子线程退出的消息。在这里，子进程1和子进程2的消息都在系统日志文件（例如“/var/log/messages”，日志文件的全路径名因版本的不同可能会有所不同）中输出。在向日志文件写入消息之后，守护进程（子进程1）循环暂停，其间隔时间为10s。 五、实验步骤
查看程序的进程和线程实验报告
查看程序的进程和线程实验报告 篇一：程序实验2：11-多线程编程---实验报告 程序实验二：11-多线程编程实验 专业班级实验日期 5.21 姓名学号实验一（p284：11-thread.c） 1、软件功能描述 创建3个线程，让3个线程重用同一个执行函数，每个线程都有5次循环，可以看成5个小任务，每次循环之间会有随即等待时间（1-10s）意义在于模拟每个任务到达的时间是随机的没有任何的特定规律。 2、程序流程设计 3．部分程序代码注释(关键函数或代码) #include #include #include #define T_NUMBER 3 #define P_NUMBER 5 #define TIME 10.0
void *thrd_func(void *arg ) { (本文来自：https://www.wendangku.net/doc/792988671.html, 小草范文网:查看程序的进程和线程实验报告) int thrd_num=(int)arg; int delay_time =0; int count =0; printf("Thread %d is staraing\n",thrd_num); for(count=0;count { delay_time =(int)(rand()*TIME/(RAND_MAX))+1; sleep(delay_time); printf("\tTH%d:job%d delay =%d\n",thrd_num,count,delay_time); } printf("%d finished\n",thrd_num); pthread_exit(NULL); } int main()
LINUX实验报告
实验报告 （ 2014/ 2015 学年第一学期） 课程名称操作系统A 实验名称文件系统 实验时间2014 年12 月8 日指导单位计算机学院计算机科学与技术系 指导教师徐鹤 学生姓名王生荣班级学号B12040809 学院(系) 计算机学院专业软件工程
实验名称文件系统指导教师徐鹤 实验类型设计实验学时 2 实验时间2014.12.08 一、实验目的和要求 1. 学习LINUX系统下对文件进行操作的各种命令和图形化界面的使用方法。 2. 深入学习和掌握文件管理系统的基本原理和LINUX等操作系统下常用的系统调用，编写一个使用系统调用的例程。 3．实现一个文本文件的某信息的插入和删除 4．实现一个记录文件的某记录的插入和删除 二、实验环境(实验设备) Windows XP + VMWare + RedHat Linux 8
三、实验过程描述与结果分析 1. 目录/proc下与系统相关的文件和目录 (1) /proc/$pid/fd：这是一个目录，该进程($PID号码进程)每个打开的文件在该目录下有一个对应的文件。 例如：#ls /proc/851/fd 0 1 2 255 这表示，851号进程目前正在使用（已经打开的）文件有4个，它们的描述符分别是0、1、2、255。其中，0、1、2 依次分别是进程的标准输入、标准输出和标准错误输出设备。 (2)/proc/filesystems:该文件记录了可用的文件系统类型。 (3)/proc/mounts:该记录了当前被安装的文件系统信息 例如：#cat /proc/mount (4)/proc/$pid/maps:该文件记录了进程的映射内存区信息。 例如：#cat /proc/851/maps 2.常用命令讲解 ls 命令 用来查看用户有执行权限的任意目录中的文件列表，该命令有许多有趣的选项。例如： $ ls -liah * 22684 -rw-r--r-- 1 bluher users 952 Dec 28 18:43 .profile
Linux下查看进程和线程
在Linux中查看线程数的三种方法 1、top -H 手册中说：-H : Threads toggle 加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。 2、ps xH 手册中说：H Show threads as if they were processes 这样可以查看所有存在的线程。 3、ps -mp
linux进程线程管理实验报告
linux进程线程管理实验报告
————————————————————————————————作者：————————————————————————————————日期：
西安郵電學院 操作系统LINUX实验报告 题目1：进程______ 题目2：线程管理__ 题目3：互斥_____系部名称：计算机学院 专业名称：软件工程 班级：0802 学号：04085048 学生姓名：郭爽乐 时间：2010-10-31
实验一: 进程管理 一．实验目的 通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点， 掌握在POSIX 规范中fork和kill系统调用的功能和使用。 二．实验要求 2.1 实验环境要求 1. 硬件 (1) 主机：Pentium III 以上； (2) 内存：128MB 以上； (3) 显示器：VGA 或更高； (4) 硬盘空间：至少100MB 以上剩余空间。 2. 软件 Linux 操作系统，内核2.4.26 以上，预装有X-Window 、vi、gcc、gdb 和任意web 浏览器。 2.2 实验前的准备工作 学习man 命令的用法，通过它查看fork 和kill 系统调用的在线帮助，并阅读参 考资料，学会fork 与kill 的用法。 复习C 语言的相关内容。 三、实验内容 3.1 补充POSIX 下进程控制的残缺版实验程序 3.2回答下列问题： 1. 你最初认为运行结果会怎么样？ 2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。 3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？ 4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？ 5. 使用kill 命令可以在进程的外部杀死进程。进程怎样能主动退出？这两种退出方式哪种更好一些？ 四、实验结果 4.1 补充完全的源程序 #include
操作系统实验报告(包括线程,进程,文件系统管理,linux+shell简单命令)
操作系统实验报告 班级：030613 学号：03061331 姓名：裴帅帅
实验一：进程的建立 一、实验内容 创建进程及子进程，在父子进程间实现进程通信，创建进程并显示标识等进 程控制块的属性信息，显示父子进程的通信信息和相应的应答信息。 使用匿名管道实现父子进程之间的通信。 二、源程序 1、创建匿名管道 SECURITY_ATTRIBUTES sa; sa.bInheritHandle=true; sa.lpSecurityDescriptor=NULL; sa.nLength=sizeof(SECURITY_ATTRIBUTES); if(!CreatePipe(&m_hRead,&m_hWrite,&sa,0)) { MessageBox("创建匿名管道失败"); return false; } 2、创建子进程 STARTUPINFO si; ZeroMemory(&si,sizeof(STARTUPINFO)); si.cb=sizeof(STARTUPINFO); si.dwFlags=STARTF_USESTDHANDLES; si.hStdInput=m_hRead; si.hStdOutput=m_hWrite; si.hStdError=GetStdHandle(STD_ERROR_HANDLE); if(!CreateProcess(NULL,"子 进.exe",NULL,NULL,true,0,NULL,NULL,&si,&pi)) { MessageBox("创建子进程失败"); CloseHandle(m_hRead); CloseHandle(m_hWrite); m_hRead=NULL; m_hWrite=NULL; return; } 3、销毁子进程 if(m_hRead) CloseHandle(m_hRead);
实验四 同步与互斥 Linux实验报告
实验四同步与互斥 【实验目的和要求】 1、掌握进程（线程）的同步与互斥。 2、掌握生产者消费者问题的实现方法。 3、掌握多线程编程方法。 【实验内容】 实现生产者消费者问题 1、有一个仓库，生产者负责生产产品，并放入仓库，消费者会从仓库中拿走产品(消费)。 2、仓库中每次只能入一个(生产者或消费者)。 3、仓库中可存放产品的数量最多10个,当仓库放满时，生产者不能再放入产品。 4、当仓库空时，消费者不能从中取出产品。 5、生产、消费速度不同。 【实验原理】 1、信号量mutex提供对缓冲池访问的互斥要求并初始化为1，信号量empty和 full分别用来表示空缓冲项和满缓冲项的个数，信号量empty初始化为n，信号量full初始化为0。 2、定义如下结构及数据： 定义缓冲区内的数据类型：typedef int buffer_item; 缓冲区：buffer_item buffer[BUFFER_SIZE];
对缓冲区操作的变量：int in,out; 信号量mutex提供了对缓冲池访问的互斥要求：pthread_mutex_t mutex; 信号量empty和full分别表示空缓冲顶和满缓冲顶的个数：sem_t empty,full; 可以设定生产者的生产速度及消费者的消费速度：int pro_speed,con_speed; 对缓冲区操作的自增函数：#define inc(k) if(k < BUFFER_SIZE) k = k+1;else k=0 3、并定义了如下实现问题的函数模块： 将生产的产品放入缓冲区： int insert_item(buffer_item item) 从缓冲区内移走一个产品： int remove_item(buffer_item *item) 生产者进程：void *producer(void *param) 消费者进程：void *consumer(void *param) 生产者结构进程消费者结构进程 【程序代码】 //sx.c #include
linux操作系统实验报告
LINUX操作系统实验报告 姓名 班级学号 指导教师 2011 年 05月 16 日 实验一在LINUX下获取帮助、Shell实用功能 实验目的： 1、掌握字符界面下关机及重启的命令。 2、掌握LINUX下获取帮助信息的命令：man、help。 3、掌握LINUX中Shell的实用功能，命令行自动补全，命令历史记录，命令的排列、替
换与别名，管道及输入输出重定向。 实验容： 1、使用shutdown命令设定在30分钟之后关闭计算机。 2、使用命令“cat /etc/cron.daliy”设置为别名named，然后再取消别名。 3、使用echo命令和输出重定向创建文本文件/root/nn，容是hello，然后再使用追加重定向输入容为word。 4、使用管道方式分页显示/var目录下的容。 5、使用cat显示文件/etc/passwd和/etc/shadow，只有正确显示第一个文件时才显示第二个文件。 实验步骤及结果： 1.用shutdown命令安全关闭系统，先开机在图形界面中右击鼠标选中新建终端选项中输入 命令Shutdown -h 30 2、使用命令alias将/etc/cron.daliy文件设置为别名named，左边是要设置的名称右边是要更改的文件。查看目录下的容，只要在终端输入命令即可。取消更改的名称用命令unalias 命令：在命令后输入要取消的名称，再输入名称。 3.输入命令将文件容HELLO重定向创建文本文件/root/nn，然后用然后再使用追加重定向输入容为word。步骤与输入容HELLO一样，然后用命令显示文件的全部容。 4.使用命令ls /etc显示/etc目录下的容，命令是分页显示。“|”是管道符号，它可以将多个命令输出信息当作某个命令的输入。
linux使用多线程解决“读者—写者”问题实验报告
计算机科学与技术系 实验（项目）报告 一、基本信息 二、目的与要求 目的： 通过实验掌握Linux环境下多线程程序的开发方法。 要求： 1.掌握线程的基本概念及操作； 2.掌握线程间通信的基本方法； 3.掌握Linux环境下多线程程序的开发方法及步骤。 三、完成实验（项目）过程和效果 内容： 1.问题分析； 有100个读线程和100个写线程共同读、写文件 (1)允许多个reader同时读一个文件； (2)当有一个reader在读文件时，不允许writer写文件； (3)当有一个writer在写文件时，不允许reader读文件，也不允许其 他writer写文件。
2.程序实现； 3.程序的调试与运行。 步骤： 1.问题分析 可以利用读写锁解决读者-写者问题 2.程序实现 1)读者： void *Reader(void *id) { RandomSleep(); pthread_rwlock_rdlock(&rwlock); ReaderNum++; ReadFile(*((int *)id)); ReaderNum--; pthread_rwlock_unlock(&rwlock); } 2)写者： void *Writer(void *id) { RandomSleep(); pthread_rwlock_wrlock(&rwlock); WriterNum++; WriteFile(*((int *)id)); WriterNum--;
pthread_rwlock_unlock(&rwlock); } 3)线程的创建： for(i=0; i 实验一 实验名称：Linux 基本命令的使用 实验时间：2学时 实验目的：熟练使用Linux字符界面、窗口系统的常用命令。 实验内容 （一）Linux操作基础 1.重新启动linux或关机（poweroff，shutdown，reboot，init 0，init 6) 2.显示系统信息（uname），显示系统日期与时间，查看2014年日历（date，cal） ①uname:查看系统与内核相关信息 uname -asrmpi 参数: -a :所有系统相关的信息； -s: 系统内核名称； -r: 内核的版本； -m:本系统的硬件名称，如i686或x86_64； -p: CPU的类型，与-m类似，只是显示的是CPU的类型； -i :硬件的平台(ix86). ②date:显示日期的命令 ③cal:显示日历 单独cal:列出当前月份的日历 cal 2014:列出2014年的日历 cal 5 2014:列出2014年五月的目录 3.使用帮助命令(man，help) ①man:是manual（操作说明）的简写，是在线帮助系统 man后跟某个命令就会详细说明此命令，例如：man man就会详细说明man 这个命令的用法； ②help：也是帮助命令，一般会在命令后，例如：cd --help 就会列出cd命令的使用说明。 4.查看当前登陆用户列表(who)，显示当前用户（whoami） ①who：显示目前已登录在系统上面的用户信息； ②whoami：查询当前系统账户 5.建立一个新用户mytest，设定密码（useradd，passwd） ①useradd mytest(建立新用户mytest)； Linux 线程实现机制分析 杨沙洲 国防科技大学计算机学院 2003 年 5 月 19 日 自从多线程编程的概念出现在 Linux 中以来，Linux 多线应用的发展总是与两个问题脱不开干系：兼容性、 效率。本文从线程模型入手，通过分析目前 Linux 平台上最流行的 LinuxThreads 线程库的实现及其不足，描述了 Linux 社区是如何看待和解决兼容性和效率这两个问题的。 一 .基础知识：线程和进程 按照教科书上的定义，进程是资源管理的最小单位，线程是程序执行的最小单位。在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持 SMP 以及减小（进程/线程）上下文切换开销。 无论按照怎样的分法，一个进程至少需要一个线程作为它的指令执行体，进程管理着资源（比如cpu 、内存、 文件等等），而将线程分配到某个cpu 上执行。一个进程当然可以拥有多个线程，此时，如果进程运行在SMP 机器上，它就可以同时使用多个cpu 来执行各个线程，达到最大程度的并行，以提高效率；同时，即使是在单cpu 的机器上，采用多线程模型来设计程序，正如当年采用多进程模型代替单进程模型一样，使设计更简 洁、功能更完备，程序的执行效率也更高，例如采用多个线程响应多个输入，而此时多线程模型所实现的功能实际上也可以用多进程模型来实现，而与后者相比，线程的上下文切换开销就比进程要小多了，从语义上 来说，同时响应多个输入这样的功能，实际上就是共享了除cpu 以外的所有资源的。 针对线程模型的两大意义，分别开发出了核心级线程和用户级线程两种线程模型，分类的标准主要是线程的调度者在核内还是在核外。前者更利于并发使用多处理器的资源，而后者则更多考虑的是上下文切换开销。在目前的商用系统中，通常都将两者结合起来使用，既提供核心线程以满足smp 系统的需要，也支持用线程 库的方式在用户态实现另一套线程机制，此时一个核心线程同时成为多个用户态线程的调度者。正如很多技 术一样，"混合"通常都能带来更高的效率，但同时也带来更大的实现难度，出于"简单"的设计思路，Linux 从 一开始就没有实现混合模型的计划，但它在实现上采用了另一种思路的"混合"。 在线程机制的具体实现上，可以在操作系统内核上实现线程，也可以在核外实现，后者显然要求核内至少实现了进程，而前者则一般要求在核内同时也支持进程。核心级线程模型显然要求前者的支持，而用户级线程模型则不一定基于后者实现。这种差异，正如前所述，是两种分类方式的标准不同带来的。 当核内既支持进程也支持线程时，就可以实现线程-进程的"多对多"模型，即一个进程的某个线程由核内调度，而同时它也可以作为用户级线程池的调度者，选择合适的用户级线程在其空间中运行。这就是前面提到的"混合"线程模型，既可满足多处理机系统的需要，也可以最大限度的减小调度开销。绝大多数商业操作系统（如Digital Unix 、Solaris 、Irix ）都采用的这种能够完全实现POSIX1003.1c 标准的线程模型。在核外实现的线程又可以分为"一对一"、"多对一"两种模型，前者用一个核心进程（也许是轻量进程）对应一个线程，将线程调度等同于进程调度，交给核心完成，而后者则完全在核外实现多线程，调度也在用户态完成。后者就是前面提到的单纯的用户级线程模型的实现方式，显然，这种核外的线程调度器实际上只需要完成线程运行栈的切换，调度开销非常小，但同时因为核心信号（无论是同步的还是异步的）都是以进程为单位的，因而无法定位到线程，所以这种实现方式不能用于多处理器系统，而这个需求正变得越来 内容： 一.基础知识：线程和进程 二.Linux 2.4内核中的轻量进程实现 三.LinuxThread 的线程机制 四.其他的线程实现机制 参考资料 关于作者 对本文的评价 订阅: developerWorks 时事通讯 实验1：安装L i n u x系统 【实验目的和要求】：安装Linux系统，掌握操作系统的系统配置，建立应用环境的过程。 【实验内容】： 1、首先在windows系统中安装虚拟机。在网上找到VMwareWorksttionPro版本， 确定安装目录。一直下一步，不需要太多的说明。 2、 图为安装完成后的界面。 3、然后在阿里巴巴开源镜像网站下载centos系统镜像，然后虚拟机创建新的虚 拟机， 进行一些简单的虚拟机设置，设置了网络链接nat模式等等。 安装完成后的界面 实验2：Linux下c语言开发 【实验目的】：学会和掌握用c语言开发一个应用程序的全过程，包括，编译，调试等等。 【实验步骤】：首先在系统中查看是否已经安装有gcc,输入查看命令发现没有，于是需要安装gcc。在centos系统中可以使用比较简便的yum命令。在之前已经配置好了yum源。直接输入yuminstallgcc。回车自动安装程序和需要的依赖包。 因为虚拟机中和电脑很多地方切换使用不方便，所以安装了xshell软件。图为xshell中的截图。 安装完毕。然后使用vi或者vim编写 运行，在屏幕上打印出hello，world。 实验3：进程创建 【实验目的和要求】1.了解进程的概念及意义；2.了解子进程和父进程 3.掌握创建进程的方法。 【实验内容】1.子进程和父进程的创建； 2.编写附件中的程序实例 【实验步骤】一1、打开终端，输入命令，在文件中输入中的代码； 2、输入命令，回车后显示无错误； 3、输入命令：./1_fork运行程序。 二、1、打开终端，输入命令，在文件中输入中的代码； 2、输入命令，回车后显示无错误： 3、输入命令：./2_vfork运行程序。 从上面可以看到两次的运行结果不一样。我们知道write函数是不带缓存的。因为在fork之前调用write，所以其数据写到标准输出一次。但是，标准I/O库是带缓存的。如果标准输出连到终端设备，则它是行缓存的，否则它是全缓存的。当以交互方式运行该程序时，只得到printf输出的行一次，其原因是标准输出缓存由新行符刷新。但是当将标准输出重新定向到一个文件时，却得到printf输出行两次。其原因是，在fork之前调用了printf一次，当调用fork时，该行数据仍在缓存中，然后在父进程数据空间复制到子进程中时，该缓存数据 也被复制到子进程中。于是那时父、子进程各自有了带该行内容的缓存。在exit 之前的第二个printf将其数据添加到现存的缓存中。当每个进程终止时，缓存中的内容被写到相应文件中。 linux进程间通讯 管道（FIFO）： 管道可分为命名管道和非命名管道（匿名管道），匿名管道只能用于父、子进程间通讯，命名管道可用于非父子进程。命名管道就是FIFO，管道是先进先出的通讯方式。 消息队列： 消息队列用于2个进程间通讯，首先在1个进程中创建1个消息队列，然后可向消息队列中写数据，而另一进程可从该消息队列中读取数据。 注意，消息队列是以创建文件的方式建立的，若1个进程向某消息队列中写入数据后，另一进程并未读取这些数据，则即使向消息队列中写数据的进程已退出，但保存在消息队列中的数据并未消失，也就是说下次再从这个消息队列中读数据时，还是会读出已退出进程所写入的数据。 信号量： linux中的信号量类似于windows中的信号量。 共享内存： 共享内存，类似于windows中dll的共享变量，但linux下的共享内存区不需要象DLL这样的东西，只要先创建1个共享内存区，其它进程按照一定步骤就能访问到这个共享内存区中的数据（可读可写）。 信号——signal 套接字——socket 各种ipc机制比较： 1.匿名管道：速度较慢，容量有限，且只有父、子进程间能通讯； 2.命名管道（FIFO）：任何进程间都能通讯，但速度较慢； 3.消息队列：容量受系统限制，且要对读出的消息进行测试（读出的是新写入的消息，还是以前写入的， 尚未被读取的消息）； 4.信号量：不能传递复杂信息，只能用来同步； 5.共享内存：容量大小可控，速度快，但共享内存区不包含同步保护，对共享内存区的访问需由用户实 现同步保护。 另外，共享内存同样可用于线程间通讯，不过没必要，线程间本来就已共享了同一进程内的一块内存。 线程间同步方法： 1.临界区：使多线程间串行访问公共资源或1段代码，速度较快，适合控制数据访问； 2.互斥量：为同步对共享资源的单独访问而设计的； 3.信号量：为控制1个具有有限数量用户资源而设计； 4.事件对象：用来通知线程有一些事件已发生，从而启动后继任务。 操作系统上机实验报告 实验名称： 进程和线程 实验目的： 理解unix/Linux下进程和线程的创建、并发执行过程。 实验内容： 1．进程的创建 2．多线程应用 实验步骤及分析： 一、进程的创建 下面这个C程序展示了UNIX系统中父进程创建子进程及各自分开活动的情况。 fork( ) 创建一个新进程。 系统调用格式： pid=fork( ) 参数定义： int fork( ) fork( )返回值意义如下： 0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。 >0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。 -1：创建失败。 如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。此时OS在内存中建立一个新进程，所建的新进程是调用fork( )父进程（parent process）的副本，称为子进程（child process）。子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。父进程与子进程并发执行。 2、参考程序代码 /*process.c*/ #include 燕山大学 Linux技术上机实验指导 实验一Linux系统安装与简单配置 一、实验目的 1．掌握Linux系统安装的分区准备。 2．掌握Linux系统的安装步骤。 3．掌握Linux系统分区的挂载和卸载。 4．掌握Linux系统的启动和关闭操作。 二、实验内容 1．安装VMware虚拟机，设置光盘驱动器，为Linux系统安装做准备。2．在虚拟机下安装Linux操作系统（如Ubuntu桌面版本）。 3．配置Linux系统运行环境。 4．利用空闲分区创建新的Linux系统分区。 5．将新的Linux系统分区挂载到系统中；卸载新挂载的分区，重新挂载到目录树中的其他位置。 三、主要的实验步骤 1．制定安装系统的分区计划。 2．配置光驱引导镜像文件iso，启动系统，开始安装过程。 3．根据安装计划，对磁盘空间进行分区设置。 4．根据系统安装指导，完成Linux系统的安装过程。 5．安装成功后，退出系统，重新启动虚拟机，登陆Linux操作系统。6．对Linux系统进行配置，如网络设备等。 7．利用磁盘使用工具和mount，将新创建的Linux系统分区挂载到系统中。将新挂载的分区卸载，并重新挂载到目录树的其他位置。 实验二Linux常用命令使用 一、实验目的 1．掌握Linux一般命令格式。 2．掌握有关文件和目录操作的常用命令。 3．熟练使用man命令。 二、实验内容 1．熟悉cd、date、pwd、cal、who、echo、clear、passwd等常用命令。2．在用户主目录下对文件进行操作：复制一个文件、显示文件内容、查找指定内容、排序、文件比较、文件删除等。 3．对目录进行管理：创建和删除子目录、改变和显示工作目录、列出和更改文件权限、链接文件等。 4．利用man命令显示date、echo等命令的手册页。 5．显示系统中的进程信息。 三、主要实验步骤 1．登陆进入系统，修改个人密码。 2．使用简单命令：date、cal、who、echo、clear等，了解Linux命令格式。 LINUX的FTP实验报告 实验需求：为了实现文件传输，共享资源 实验环境：一台centos和一台XP客户机 实验步骤：首先打开centos再将安装光盘挂载上，输入命令“rpm -qa|grep vsftpd”查看是否有此软件，如果没有进入到光盘的挂载目录，然后输入命令“rpm -ivh vsftpd(然后使用补全)”，如图1所示,安装软件完成 图1 下面我们到配置文件中设置一下，输入命令“vi /etc/vsftpd/”就出现如图2所示，用末行模式加上行号 图2 我们将文件中的第27和31行启用，就是把前面的＃删除即可，然后在31行下面写上“anon_other_write_enable=YES”这一行的意思是给匿名用户删除权限，第27行是给匿名用户上传权限，31行是给匿名用户创建、修改文件夹权限，如图3所示,修改完成后保存退出 图3 然后我们再到“/var/ftp/”下将pub文件夹的其它用户权限设为读、写、执行，输入命令“chmod o+w pub”如图4所示 图4 下面我们将两台虚拟机网段设置成3,将centos的IP设置为将XP的IP设置为如图5-1,5-2所示,都点击确定完成设置 图5-1 图5-2 然后我们在XP上测试一下网络是否畅通，如图6所示网络畅通 图6 下面我们到centos上启动FTP服务，输入命令“service vsftpd restart”， ，我们启动成功，下面我们到XP上测试，我们的设置是否生效，如图7所示，我们访问成功 图7 我们测试一下上传和删除功能，如图8-1,8-2所示，设置生效，我们实验成功linux实验报告
Linux 线程实现机制分析
Linux操作系统实验实验报告
linux进程间通讯
操作系统实验报告理解Linux下进程和线程的创建并发执行过程。
Linux实验报告
LINUX的FTP实验报告
- 实验七：Linux多线程编程(实验报告)
- linux进程线程管理实验报告
- linux多线程实验报告
- 查看程序的进程和线程实验报告
- 操作系统实验报告理解Linux下进程和线程的创建并发执行过程。
- 实验七：Linux多线程编程(实验报告)
- 中南大学--Linux第四次实验报告
- 操作系统实验一进程与线程—Linux进程与线程通讯实验报告
- LINUX嵌入式实验报告(DOC)
- 实验四 同步与互斥 Linux实验报告
- 操作系统实验报告理解Linux下进程和线程的创建并发执行过程。
- 多核程序设计Linux多线程编程
- Linux系统线程死锁实验报告
- linux操作系统-实验五-Linux 多线程编程
- Linux程序设计实验报告大作业
- 操作系统实验报告(包括线程,进程,文件系统管理,linux+shell简单命令)
- 实验四-同步与互斥-Linux实验报告
- linux进程线程管理实验报告
- Linux多任务多线程编程-
- 实验二-多线程应用程序设计