#include <stdio.h> /* standard input/output routines. */
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

#include <string.h>>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>

#define MAX_LINE_LEN 1000 /* maximal line length supported. */

void cp(int argc, char* argv[])
{
 char* file_path_from; /* path to source file. */
 char* file_path_to; /* path to target file. */
 FILE* f_from; /* stream of source file. */
 FILE* f_to; /* stream of target file. */
 char buf[MAX_LINE_LEN+1]; /* input buffer. */

 /* read command line arguments */
 if (argc != 3 || !argv[1] || !argv[2]) {
fprintf(stderr, "Usage: %s <source file path> <target file path>\n",
argv[0]);
exit(1);
 }
 file_path_from = argv[1];
 file_path_to = argv[2];

 /* open the source and the target files. */
 f_from = fopen(file_path_from, "r");
 if (!f_from) {
fprintf(stderr, "Cannot open source file: ");
perror("");
exit(1);
 }
 f_to = fopen(file_path_to, "w+");
 if (!f_from) {
fprintf(stderr, "Cannot open target file: ");
perror("");
exit(1);
 }

 /* copy source file to target file, line by line. */
 while (fgets(buf, MAX_LINE_LEN+1, f_from)) {
if (fputs(buf, f_to) == EOF) { /* error writing data */
 fprintf(stderr, "Error writing to target file: ");
 perror("");
 exit(1);
}
 }
 if (!feof(f_from)) { /* fgets failed _not_ due to encountering EOF */
 fprintf(stderr, "Error reading from source file: ");
 perror("");
 exit(1);
 }

 /* close source and target file streams. */
 if (fclose(f_from) == EOF) {
fprintf(stderr, "Error when closing source file: ");
perror("");
 }
 if (fclose(f_to) == EOF) {
fprintf(stderr, "Error when closing target file: ");
perror("");
 }
}
int main(int argc, char* argv[])
{
 pid_t pid,old_ppid,new_ppid;
 pid_t child,parent;
 
 parent=getpid();
 
 int t_s= time((time_t*)NULL);
 printf("\nstart time:%d",t_s);
 if((child=fork())<0)
 {
 fprintf(stderr,"%s:fork of child failed:%s\n",argv[0],strerror(errno));
 exit(1);
 }
 else if(child==0)
 {
 int i=1;
 double tempresult = 1;
 for(i=1;i<=50;i++)
 {
 tempresult = tempresult * i;
 }
 printf("\nchild progress:%d",getpid());
 printf("\n50!=%f",tempresult);
 exit(1);
 }
 
 cp(argc,argv);
 printf("\nparent progress:%d",getpid());
 
 File *f_to = fopen(argv[2],"a+");
 char Line[100];
 sprintf(Line,"%f",tempresult);
 fprintf(f_to,"%s",Line);
 fclose(f_to);

 
 int t_e= time((time_t*)NULL);
 printf("\nendtime is :%d",t_e);
 int usedtime;
 usedtime=t_e - t_s;
 printf("\nused time is :%d",usedtime);
 
 
}

/*请求方程序msgclient.c*/ 

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include <sys/types.h>

static struct msgbuf1 /*定义双方消息的格式*/
{
long mtype;
char mtext[100]; /*初定双方消息内容的大小为 100 */
} sndbuf, rcvbuf, *msgp ;

extern int errno;

int main() 
{ 
 int rtrn, msqid ;
 char name[10];
 char type[3];
 double balance;
 msqid = msgget(0x888,IPC_CREAT|0600);
 if (msqid == -1 ) /*创建消息队列失败*/
 {
 fprintf(stderr, "msgget 888 failed !\n");
 exit(-1);
 }
 printf("请输入消息的待接收消息的类型(2位数字): ");
 scanf("%s",type);
 printf("\n");
 while(1)
 { 
 memset(&sndbuf,0,sizeof(sndbuf));
 memset(&sndbuf,0,sizeof(sndbuf));
 
 msgp=&sndbuf;
 sprintf(sndbuf.mtext,"%2.2s",type); /*格式化输入字符串到sndbuf.mtext中,获取的位数为2位*/
 printf("输入4位帐号:"); 
 scanf("%s",&sndbuf.mtext[2]); /*输入帐号,存放在缓冲区mtext[2]开始的地方*/
 sndbuf.mtext[6]=0;
 msgp->mtype=666; /*定义消息类型*/
 rtrn=msgsnd(msqid,msgp, strlen(sndbuf.mtext), 0);/*以阻塞的方式发送消息*/
 if (rtrn==-1)
 {
 perror("msgsnd"); 
 exit(-1);
 }
 msgp=&rcvbuf;
 fprintf(stderr,"正等待后台数据的处理,请稍候....");
 rtrn=msgrcv(msqid,msgp, 100, atoi(type),0);/*以阻塞的方式接收消息*/
 if(rtrn==-1)
 {
 perror("msgrcv");
 exit(-1);
 }
 sscanf(rcvbuf.mtext,"%[^|]|%lf",name,&balance);
 printf("\n姓名=%s\n",name); 
 printf("余额=%lf\n",balance);
 printf("\n");
 }
 }

/*服务方程序msgserver.c*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include <string.h>

static struct msgbuf1{
long mtype;
char mtext[100];
} sndbuf, rcvbuf , *msgp;

extern int errno;

int main()
{
 int rtrn, msqid ;
 char strbuf[100];
 msqid = msgget(0x888, IPC_CREAT|0600);
 if(msqid == -1 )
 { 
 fprintf(stderr, "msgget 888 failed !\n");
 exit(-1);
 }
 while(1) 
 {
 memset(&sndbuf,0,sizeof(sndbuf));
 memset(&rcvbuf,0,sizeof(rcvbuf));
 
 msgp=&rcvbuf;
 fprintf(stderr,"等待前台进程的请求....");
 rtrn=msgrcv(msqid, msgp, 100, 666 ,MSG_NOERROR);
 if(rtrn==-1)
 {
 perror("msgrcv");
 exit(-1);
 }
 msgp=&sndbuf;
 sprintf(strbuf,"%2.2s\0",rcvbuf.mtext);/*获取前2位*/
 msgp->mtype=atoi(strbuf);/*消息的类型*/
 printf("\n输入帐号[%4.4s]的帐户姓名:",&rcvbuf.mtext[2]); 
 scanf("%s",sndbuf.mtext); /*输入帐号姓名*/
 strcat(sndbuf.mtext,"|");
 printf("输入该帐户余额:"); /*帐户姓名|帐户余额*/
 scanf("%s",strbuf);
 strcat(sndbuf.mtext,strbuf);
 rtrn=msgsnd(msqid,msgp, strlen(sndbuf.mtext),0);
 if (rtrn==-1)
 {
 perror("msgsnd");
 exit(-1); 
 }
 printf("\n");
 }
}

// 客户端
 
#include <sys/sem.h>
#include <time.h>
#include <sys/ipc.h>

#define SEGSIZE 1024
#define READTIME 1
union semun {
 int val;
 struct semid_ds *buf;
 unsigned short *array;
} arg;

// 打印程序执行时间
void out_time(void)
{
 static long start = 0;
 time_t tm;
 if (0 == start){
 tm = time(NULL);
 start = (long)tm;
 printf(" now start ...\n");
 }
 printf(" second: %ld \n",(long)(time(NULL)) - start);
}

//创建信号量
int new_sem(key_t key)
{
 union semun sem;
 int semid;
 sem.val = 0;
 semid = semget(key,0,0);
 if (-1 == semid){
 printf("create semaphore error\n");
 exit(-1);
 }
 return semid;
}

//等待信号量变成0
void wait_v(int semid)
{
 struct sembuf sops={0,0,0};
 semop(semid,&sops,1);
}

int main(void)
{
 key_t key;
 int shmid,semid;
 char *shm;
 char msg[100];
 char i;
 
 key = ftok("/",0);
 shmid = shmget(key,SEGSIZE,0);
 
 if(-1 == shmid){
 printf(" create shared memory error\n");
 return -1;
 }
 shm = (char *)shmat(shmid,0,0);
 if (-1 == (int)shm){
 printf(" attach shared memory error\n");
 return -1;
 }
 semid = new_sem(key);
 for (i = 0;i < 3;i ++){
 sleep(2);
 wait_v(semid);
 printf("Message geted is: %s \n",shm + 1);
 out_time();
 }
 shmdt(shm);
 return 0;

}

// 服务器

#include <sys/sem.h>
#include <sys/ipc.h>

#define SEGSIZE 1024
#define READTIME 1
union semun {
 int val;
 struct semid_ds *buf;
 unsigned short *array;
} arg;
//生成信号量
int sem_creat(key_t key)
{
 union semun sem;
 int semid;
 sem.val = 0;
 semid = semget(key,1,IPC_CREAT|0666);
 if (-1 == semid){
 printf("create semaphore error\n");
 exit(-1);
 }
 semctl(semid,0,SETVAL,sem);
 return semid;
}
//删除信号量
void del_sem(int semid)
{
 union semun sem;
 sem.val = 0;
 semctl(semid,0,IPC_RMID,sem);
}

//p
int p(int semid)
{
 struct sembuf sops={0,+1,IPC_NOWAIT};
 return (semop(semid,&sops,1));
}
//v
int v(int semid)
{
 struct sembuf sops={0,-1,IPC_NOWAIT};
 return (semop(semid,&sops,1));
}
int main()
{
 key_t key;
 int shmid,semid;
 char *shm;
 char msg[7] = "-data-";
 char i;
 struct semid_ds buf;
 
 key = ftok("/",0);
 shmid = shmget(key,SEGSIZE,IPC_CREAT|0604);
 if (-1 == shmid){
 printf(" create shared memory error\n");
 return -1;
 }
 shm = (char *)shmat(shmid,0,0);
 if (-1 == (int)shm){
 printf(" attach shared memory error\n");
 return -1;
 }
 semid = sem_creat(key);
 for (i = 0;i <= 3;i++){
 sleep(1);
 p(semid);
 sleep(READTIME);
 msg[5] = '0' + i;
 memcpy(shm,msg,sizeof(msg));
 sleep(58);
 v(semid);
 }
 shmdt(shm);
 shmctl(shmid,IPC_RMID,&buf);
 del_sem(semid);
 return 0;

}

/********** testread.c ************/
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <sys/types.h>
 #include <unistd.h>
 typedef struct{
 char name[4];
 int age;
 } people;
 main(int argc, char** argv)
 {
 int shm_id,i;
 key_t key;
 people *p_map;
 char* name = ".";
 key = ftok(name,0);
 if(key == -1)
 perror("ftok error");
 shm_id = shmget(key,4096,IPC_CREAT); 
 if(shm_id == -1)
 {
 perror("shmget error");
 return;
 }
 p_map = (people*)shmat(shm_id,NULL,0);
 for(i = 0;i<10;i++)
 {
 printf( "name:%s\n",(*(p_map+i)).name );
 printf( "age %d\n",(*(p_map+i)).age );
 }
 if(shmdt(p_map) == -1)
 perror(" detach error ");
 }

/***** testwrite.c *******/
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <sys/types.h>
 #include <unistd.h>
 typedef struct{
 char name[4];
 int age;
 } people;
 
 main(int argc, char** argv)
 {
 int shm_id,i;
 key_t key;
 char temp;
 people *p_map;
 char* name = ".";
 key = ftok(name,0);
 if(key==-1)
 perror("ftok error");
 shm_id=shmget(key,4096,IPC_CREAT); 
 if(shm_id==-1)
 {
 perror("shmget error");
 return;
 }
 p_map=(people*)shmat(shm_id,NULL,0);
 temp='a';
 for(i = 0;i<10;i++)
 {
 temp+=1;
 memcpy((*(p_map+i)).name,&temp,1);
 (*(p_map+i)).age=20+i;
 }
 if(shmdt(p_map)==-1)
 perror(" detach error ");
 }

题目一：编译调试运行下面的程序，并回答问题。
/* example.c*/
#include <stdio.h>
#include <pthread.h>
void thread(void)
{
　int i;
　for(i=0;i<3;i++)
　printf("This is a pthread\n");
}

int main(void)
{
　pthread_t id;
　int i,ret;
　ret=pthread_create(&id,NULL,(void *) thread,NULL);
　if(ret!=0)
{
　　 printf ("Create pthread error!n");
　exit (1);
}
for(i=0;i<3;i++)
　　printf("This is the main process\n");
　pthread_join(id,NULL);
　return (0);
}
问题：多次运行该程序，输出结果是否一样？为什么？

题目二：利用互斥锁和条件变量编程解决生产者－消费者问题。
实验提示：参见《操作系统原理》中的算法实现

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;/*初始化互斥锁*/
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;/*初始化条件变量*/

void *thread1(void *);
void *thread2(void *);

int i=1;
int main(void)
{
 pthread_t t_a;
 pthread_t t_b;

 pthread_create(&t_a,NULL,thread2,(void *)NULL);/*创建线程t_a*/
 pthread_create(&t_b,NULL,thread1,(void *)NULL); /*创建进程t_b*/
 pthread_join(t_b, NULL);/*等待线程t_b结束*/
 pthread_join(t_a, NULL);/*等待线程t_a结束*/
 pthread_mutex_destroy(&mutex);
 pthread_cond_destroy(&cond);
 exit(0);
}

void *thread1(void *junk)
{
 for(i=1;i<=9;i++) 
 {
 pthread_mutex_lock(&mutex);/*锁住互斥量*/
 if(i%3==0)
 pthread_cond_signal(&cond);/*条件改变，发送信号，通知t_b线程*/
 else 
 printf("thead1:%d\n",i);
 pthread_mutex_unlock(&mutex);/*解锁互斥量*/

 sleep(1);
}

}

void *thread2(void *junk)
{
 while(i<9)
 {
 pthread_mutex_lock(&mutex);
 if(i%3!=0)
 pthread_cond_wait(&cond,&mutex);/*等待*/
 printf("thread2:%d\n",i);
 pthread_mutex_unlock(&mutex);
 sleep(1);
}
}

#include <pthread.h>
#include <stdio.h>

void print_message_function( void *ptr );
main( )
 {
 pthread_t thread1, thread2;
 char *message1 = "Hello";
 char *message2 = "World";
 pthread_create(&thread1,NULL,(void*)&print_message_function, (void*) message1);
 
 pthread_create(&thread2,NULL,(void*)&print_message_function, (void*) message2);
 exit( 0 );
 }
 void print_message_function( void *ptr )
 {
 char *message;
 message = (char *) ptr;
 printf("%s ", message);
 }

#include <stdio.h>
#include <pthread.h>

void* create(void* arg)
 {
 printf(" new thread is created...\n ");
 return(void*);
 }

 int main(int argc,char*argv[])
 {
 pthread_t tid; 
 int error;
 void *temp; 
 error = pthread_create(&tid,NULL,create,NULL); 
 if(error!=0)
 {
 printf("thread is not created... \n");
 return 1;
 }
 error = pthread_join( tid, &temp);
 if(error!=0)
 {
 printf("thread is not exit... ");
 return 2;
 }
 printf("thread is exit code %d\n ",(int*)temp);
 sleep(1);
 return 0;
 }

#include <stdio.h>
#include <pthread.h>
#include <stdio.h>

void *thread_function(void *arg);

int run_now=1; /*用run_now代表共享资源*/ 
pthread_mutex_t work_mutex; /*定义互斥量*/

int main()

{
int res;
int print_count1=0;
pthread_t a_thread;
if(pthread_mutex_init(&work_mutex,NULL)!=0) /*初始化互斥量*/
{
 perror("Mutex init faied");
 exit(1);
}
if(pthread_create(&a_thread,NULL,thread_function,NULL)!=0)/*创建新线程*/
{
 perror("Thread createion failed");
 exit(1);
}
if(pthread_mutex_lock(&work_mutex)!=0) /*对互斥量加锁*/
{
 perror("Lock failed");
 exit(1);
}
else
 printf("main lock\n");

while(print_count1++<5) 
{
 if(run_now==1) /* 线程：如果run_now为1就把它修改为2*/
 {
 printf("main thread is run\n");
 run_now=2;
 }
 else
 {
 printf("main thread is sleep\n");
 sleep(1);
 }
}
if(pthread_mutex_unlock(&work_mutex)!=0) /*对互斥量解锁*/
 {
 perror("unlock failed");
 exit(1);
 }
else
 printf("main unlock\n");
pthread_join(a_thread,NULL); /*等待子线程结束*/
pthread_mutex_destroy(&work_mutex); /*收回互斥量资源*/

exit(0);
}

void *thread_function(void *arg)
{
int print_count2=0;
sleep(1);
if(pthread_mutex_lock(&work_mutex)!=0)
{
 perror("Lock failed");
 exit(1);
}
else
 printf("function lock\n");

while(print_count2++<5)
{
 if(run_now==2) /*线程如果run_now为1就把它修改为1*/
 {
 printf("function thread is run\n");
 run_now=1;
 }
 else
 {
 printf("function thread is sleep\n");
 sleep(1);
 }
}

if(pthread_mutex_unlock(&work_mutex)!=0) /*对互斥量解锁*/
{
 perror("unlock failed");
 exit(1);
}
else
 printf("function unlock\n");
 pthread_exit(NULL);
}

#include <pthread.h>
#include <stdio.h>

void cleanup(void *arg)
{
 printf("cleanup: %s\n",(char *)arg);
}

void *thr_fn(void *arg) /*线程入口地址*/
{
 printf("thread start\n");
 pthread_cleanup_push(cleanup,"thread first handler");/*设置第一个线程处理程序*/
 pthread_cleanup_push(cleanup,"thread second handler"); /*设置第二个线程处理程序*/
 printf("thread push complete\n");
 pthread_cleanup_pop(0); /*取消第一个线程处理程序*/
 pthread_cleanup_pop(0); /*取消第二个线程处理程序*/
}

int main()
{
 pthread_t tid;
 void *tret;
 pthread_create(&tid,NULL,thr_fn,(void *)1); /*创建一个线程*/
 pthread_join(tid,&tret); /*获得线程终止状态*/
 printf("thread exit code %d\n",(int)tret);
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void *thread_function(void *arg);
int run_now=1; /*用run_now代表共享资源*/

int main()
{
int print_count1=0; /*用于控制循环*/
pthread_t a_thread; 
if(pthread_create(&a_thread,NULL,thread_function,NULL)!=0)/*创建一个线程*/
{
 perror("Thread createion failed");
 exit(1);
}
while(print_count1++<5)
{
 if(run_now==1) /*主线程：如果run_now为1就把它修改为2*/
 {
 printf("main thread is run\n");
 run_now=2; 
 }
 else
 {
 printf("main thread is sleep\n");
 sleep(1);
 }
}
pthread_join(a_thread,NULL); /*等待子线程结束*/
exit(0);
}

void *thread_function(void *arg)
{
int print_count2=0;
while(print_count2++<5)
{
 if(run_now==2) /*子线程：如果run_now为1就把它修改为1*/
 {
 printf("function thread is run\n");
 run_now=1;
 }
 else
 {
 printf("function thread is sleep\n");
 sleep(1);
 }
}
pthread_exit(NULL);

}