리눅스가 여러 프로세스를 만들 수 있나요?

#include <unistd.h>
pid_t fork(void);
  		返回值:  > 0表示处于父进程中 这个时候的返回值就是**子进程进程id号**
                  ==0 表示处于子进程中
                  < 0 创建进程出错
                  
#include <sys/types.h>
  		 #include <unistd.h>
		pid_t vfork(void);

    #include <stdlib.h>
    void exit(int status); 
	void _exit(int status);
	参数：
          status --->进程退出时的状态
          status在实际编写程序中是可以自己约定的：
          比如：  exit（2）----》出现打开文件错误
                  exit（3）----》出现段错误（逻辑错误）
                  exit（0）----》正常退出
		  返回：  void
	
	区别：
          exit（）在退出的时候会刷新IO缓冲区，然后才退出（负责任的退出）
          _exit() 直接退出（不负责任的退出）

	#include <sys/wait.h>
    pid_t wait(int *stat_loc);
   返回值：你回收的那个子进程的id号
   参数：stat_loc --》保存子进程退出时的状态信息(不仅仅只是返回值)
  		 stat_loc里面不仅仅只是保存了exit退出时的数值，它还保存了子进程退出时是哪个信号让它退出的，		
  	    出错了是什么原因导致的。

    #include <unistd.h>
   int pipe(int fildes[2]);
   参数：fildes[2]里面放的是两个文件描述符fildes[0]，fildes[1]
         fildes[0] 读端
         fildes[1] 写端
   返回值：成功返回0    失败返回-1

 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

 #include <signal.h>
 int kill(pid_t pid, int sig);
 参数：
   pid ----》进程的id
			正数：要接收信号的进程的进程号
			0：信号被发送到所有和pid进程在同一个进程组的进程
			-1：信号发给所有的进程表中的进程(除了进程号最大的进程外)
   sig ----》信号名字
   返回值：0 成功
		   -1 出错

 #include <signal.h>
 void (*signal(int sig, void (*func)(int)))(int);  // SIGKILL
         参数：sig ----》你需要捕捉的那个信号
               void (*func)(int) ----》函数指针,回调函数，捕捉到对应的信号的时候就调用该函数；第二个参数除了可以传递一个函数指针意外，还可以使用以下两个宏定义：
                SIG_IGN ---->你捕捉到的那个信号会被忽略
                SIG_DFL-----》你捕捉的信号会采用系统默认的方式响应
		返回值：成功：设置之前的信号处理方式
			出错：-1

#include <unistd.h>
int pause(void);
	返回值：-1 把error值设为EINTR
			0 成功

#include <signal.h>

  		int sigemptyset(sigset_t *set)：清空信号掩码
        int sigfillset(sigset_t *set)：将所有的信号添加到信号掩码中
        int sigaddset(sigset_t *set, int signum)：将特定的信号添加到信号掩码中 
  		int sigdelset(sigset_t *set, int signum)：将特定的信号从掩码中删除
  		int sigismember(const sigset_t *set, int signum)：判断某个信号在不在该掩码中
		参数：sigset_t ----》存储被进程阻塞的信号

    #include <signal.h>
 	int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset)
	参数：
      how ---》SIG_BLOCK 将set所包含的信号添加到原来的信号掩码中
              SIG_SETMASK 用set去替换原来的信号掩码
              SIG_UNBLOCK 将set中包含的信号从原来的掩码中删除
      set ---》新的信号掩码
      oset ---》原本的信号掩码
 				原本进程中信号掩码包含了：SIGINT ,SIGCONT

#include <signal.h>
int sigaction(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact);
参数：
  	sig ---》你要捕捉的那个信号
    act ---》你需要捕捉的信号对应的响应函数就定义在这个结构体
    oact ---》原来的
    struct sigaction
    {
        void(*) (int)     sa_handler ----》 信号的响应函数
        sigset_t          sa_mask  ---》信号的掩码
        int               sa_flags ----》  SA_SIGINFO
        void(*) (int, siginfo_t * ，void ）---》信号的响应函数
     }
	sa_flags ---》等于SA_SIGINFO，那么信号的响应函数是void(*) (int, siginfo_t * ，void ）
          		不等于，那么信号的响应函数是void(*) (int) 
   siginfo_t---》/usr/include/i386-linux-gnu/bits/siginfo.h 保存的是信号的状态信息，信号的标号，发送该信号的进程的id等等这些

#include <sys/shm.h> 
int shmget(key_t key, size_t size, int shmflg);
返回值：成功—共享内存对象的mid（标识符） 出错—-1
参数：key----》创建共享内存需要用到的键值
      size----》内存空间的大小（字节）
      shmflg----》设置属性  IPC_CREAT   IPC_EXCL    0666组合
      
key键值的获取有两种方法：
 **方法一**：使用ftok（）生成键值
            #include <sys/types.h>
            #include <sys/ipc.h>
            key_t ftok(const char *pathname, int proj_id);
            参数：pathname----》 路径名
                  proj_id----》整数
                 ftok(“.”  ,  11)  生成一个唯一的key值
            进程1：ftok(“.”  ,  11)  ----》shmget( 100);.............
       		进程2：ftok(“/home/gec”  ,  11)  ----》shmget( 106); 
				   无法通信，要确保键值一致才能通信
       
 **方法二：**不使用ftok（），程序员自己写个数字  
          shmget((key_t)1234, size_t size, int shmflg);

#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
 返回值：成功—映射到用户空间的那片地址的首地址   出错—-1
 参数：shmid ----》使用shmget的返回值
      shmaddr----》一般设置为NULL 系统自动分配
       shmflg----》 SHM_RDONLY：共享内存只读
			        一般设置为0: 共享内存可读写 
			        if it is 0 and the calling process has read and write permission, the segment is attached for reading and writing.

#include <sys/shm.h>
int shmdt(const void *shmaddr);
参数：shmaddr----》 shmat（）共享内存映射后的地址
返回值：成功—0 	出错—-1

 #include <sys/shm.h>
 int shmctl(int shmid, int cmd, struct shmid_ds *buf);
 参数： shmid----》共享内存的id
        cmd----》IPC_RMID    删除共享内存
                 IPC_STAT  (获取对象属性)
       			 IPC_SET (设置对象属性)
        *buf----》指定IPC_STAT/IPC_SET时保存共享内存的状态信息
		返回值：成功	失败—-1

shm_write.c :----------》
int main() {
	int shmid;
	int *p;
	
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	
	// 映射共享内存到进程
	p = (int *)shmat(shmid,NULL,0);
	*p = 10;

	// 解除映射
	shmdt(p);
	
	// 删除内存
	//shmctl(shmid,IPC_RMID,NULL);
	return 0;
}

shm_read.c :----------》
int main() {
	int shmid;
	int *p;
	
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	
	// 映射共享内存到进程
	p = (int *)shmat(shmid,NULL,0);
	printf("p is :%d\n",*p);
	
	// 解除映射
	shmdt(p);

	// 删除内存
	shmctl(shmid,IPC_RMID,NULL);
	
	return 0;
}

 #include <sys/msg.h>
 int msgget(key_t key, int msgflg);

 #include <sys/msg.h>
 int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
	参数：void *msgp ----》你要发送信息就存储在这个指针中
                  在实际的编程中我们都是定义一个结构体来存储信息
                  struct msgbuf {
                      long mtype;  ----》消息的类型
                      char mtext[100]; ----》消息的内容
                    }
                    msgsz ----》消息的长度，大小
                    msgflg ----》设置为0    除开以上三种宏定义之外的----阻塞读写

#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

pthread1.c :-----------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
	int mtype;
	char msg[50];
	
};

//数据发送结构体
struct msg_snd
{
	int mtype;
	char msg[50];
};

int main(void) {
	int msgid;
	struct msg_rv data;
	struct msg_snd snddata;
	char buff[50];

	//获取msgid
	msgid = msgget((key_t)123,IPC_CREAT|0666);
	if(msgid == -1)	{
		printf("msgid failed!\n");
		return -1;
	}

	data.mtype = 88;
	snddata.mtype = 89;
	
	while(1) {
		bzero(buff,50);
		printf("please input data!\n");
		fgets(buff,50,stdin);	
		strcpy(snddata.msg,buff);
		if(strncmp(snddata.msg,"end",3)==0) {
			break;
		}
		
		msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
		usleep(20);
		printf("run here!\n");
		
		if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1) {
			printf("msgsnd failed!\n");
			return -1;
		}
		
		printf("receive data:%s\n",data.msg);
		if(strncmp(data.msg,"end",3)==0) {
			break;	
		}	
	}
	
	//撤消消息队列
	msgctl(msgid,IPC_RMID,0);
	return 0;
}

pthread2.c :------------------------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
	int mtype;
	char msg[50];
	
};

//数据发送结构体
struct msg_snd
{
	int mtype;
	char msg[50];
};

int main(void)
{
	int msgid;
	struct msg_rv data;
	struct msg_snd snddata;
	char buff[50];
	
	data.mtype = 89;
	snddata.mtype = 88;
		
	//获取msgid
	msgid = msgget((key_t)123,IPC_CREAT|0666);
	if(msgid == -1)	{
		printf("msgid failed!\n");
		return -1;
	}
	
	while(1) {	
		//接受
		if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1)
		{
			printf("msgsnd failed!\n");
			return -1;
		}
		printf("receive data:%s\n",data.msg);
		if(strncmp(data.msg,"end",3)==0) {
			break;
		}
		
		//发送
		printf("please input data:\n");
		bzero(buff,50);
		fgets(buff,50,stdin);
		strcpy(snddata.msg,buff);
		printf("data = %s\n",snddata.msg);
		if(strncmp(snddata.msg,"end",3)==0) {
			break;
		}
		msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
		printf("run here!\n");	
	}
	
	//撤消消息队列
	msgctl(msgid,IPC_RMID,0);
	return 0;
}

#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
    参数：key ----》键值
          nsems----》你创建的信号量集中信号量的个数
          semflg----》 IPC_CREAT|0666组合
	返回值：成功—信号量ID
			出错—-1

   #include <sys/sem.h>
      int semctl(int semid, int semnum, int cmd, ...);
	  返回值：成功—0 	失败—-1

  #include <sys/sem.h>
  int semop(int semid, struct sembuf *sops, size_t nsops);
  返回值：成功—0   出错—-1
  参数：semid ----》semget的返回值
        nsops ---》要操作的信号量的个数(结构体的个数)
  		sops---》信号量操作结构体
		struct sembuf {
			short  sem_num	;=>> 要操作的信号量的编号（数组下标）
			short  sem_op;   =>> 0 :  等待，直到信号量的值变成0
                            	1 :  释放资源，V操作
                           		-1 :  分配资源，P操作                    
			short  sem_flg;   =>> 0/IPC_NOWAIT/SEM_UNDO
								SEM_UNDO: 程序结束时(不论正常或不正常)，保证信号值会被重设为semop()调用前的值;
								IPC_NOWAIT: 对信号的操作不能满足时，semop()不会阻塞，并立即返回，同时设定错误信息;
		};

pthread1.c  :-----------》

int main()
{
	int semid;
	int shmid;
	char *p;
	struct sembuf mysembuf1,mysembuf2;
	
	mysembuf1.sem_num = 0;
	mysembuf1.sem_flg = SEM_UNDO;
	mysembuf1.sem_op = 1;
	
	mysembuf2.sem_num = 1;
	mysembuf2.sem_flg = SEM_UNDO;
	mysembuf2.sem_op = -1;
	
	// 创建信号量集合
	semid = semget((key_t)789,2,IPC_CREAT|0666);
	if(semid == -1)	{
		perror("creat sem failed!\n");
		return -1;
	}
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	// 映射共享内存到进程
	p = (char *)shmat(shmid,NULL,0);

	while(1) {
		semop(semid,&mysembuf2,1); // 对信号量2进行p操作（减一）
		printf("the message I recv is:%s\n",p);
		printf("please input a message!\n");
		scanf("%s",p);
		printf("message is %s\n",p);
		semop(semid,&mysembuf1,1); // 对信号量1进行v操作（加一）
	}
	
	//解除映射 
	shmdt(p);
	
	//删除共享内存
	shmctl(semid, IPC_RMID, NULL); 
}

pthread2.c  :-----------》
int main() {
	int semid;
	int shmid;
	char *p;
	struct sembuf mysembuf1,mysembuf2;
	
	mysembuf1.sem_num = 0;  // 信号集合中的第一个信号
	mysembuf1.sem_flg = SEM_UNDO;
	mysembuf1.sem_op = -1;   //p操作

	mysembuf2.sem_num = 1;  // 信号集合中的第二个信号
	mysembuf2.sem_flg = SEM_UNDO;
	mysembuf2.sem_op = 1;    // v操作
	// 创建信号量集合
	semid = semget((key_t)789,2,IPC_CREAT|0666);
	if(semid == -1)	{
		perror("creat sem failed!\n");
		return -1;
	}
	// 设置信号量的值
	semctl(semid,0,SETVAL,1);  //第一个信号量初值为1
	printf("sem num is:%d\n",semctl(semid,0,GETVAL));
	semctl(semid,1,SETVAL,0);  //第二个信号量初值为0
	printf("sem num is:%d\n",semctl(semid,1,GETVAL));
	// 创建共享内存
	shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
	if((shmid == -1)&&(errno == EEXIST)) {
		shmid = shmget((key_t)456,1024,0666);
	}
	// 映射共享内存到进程
	p = (char *)shmat(shmid,NULL,0);
	while(1) {
		semop(semid,&mysembuf1,1); // 对信号量1进行p操作（减一）不阻塞，因为初值为1
		  // 执行完这句话以后信号量的值就立马变成1
		printf("the message I recv is:%s\n",p); 
		printf("please input a message!\n");
		scanf("%s",p);
		printf("message is %s\n",p);
		semop(semid,&mysembuf2,1); // 对信号量2进行v操作（加一）不阻塞，因为初值为0	
	}
	
	//解除映射 
	shmdt(p);
	
	//删除共享内存
	shmctl(semid, IPC_RMID, NULL);
}