进程线程基础

       #include <sys/types.h>
       #include <unistd.h>
 
       pid_t fork(void);
功能：创建出一个子进程
参数：无
返回值：在父进程中，该函数返回子进程的pid号，在子进程中该函数返回0，失败返回-1并置位错误码，并且不会创建出子进程
注意：当子进程创建出来后，父子进程都会执行fork之后的语句

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid = -1;   //定义变量存储进程号
 
	pid = fork();    //创建一个子进程
 
	//后续的程序，父子进程都会执行
	if(pid > 0)
	{
		printf("这是父进程,pid = %d\n", pid);
	}else if(pid == 0)
	{
		printf("这是子进程,pid = %d\n", pid);
	}else 
	{
		perror("fork error");
		return -1;
	}
 
	printf("hello world\n");
	while(1);
 
 
	return 0;
}
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid = -1;
 
	//创建出子进程
	pid = fork();
 
	if(pid > 0)
	{
		//父进程要执行的任务
		char sendbuf[128] = "";
 
		while(1)
		{
			scanf("%s", sendbuf);
			printf("您发送的数据%s\n", sendbuf);
			if(strcmp(sendbuf, "quit") == 0)
			{
				break;
			}
		}
 
 
	}else if(pid == 0)
	{
		//子进程要执行的任务
		char rcvbuf[20] = "";
 
		//打开文件
		int fd = open("./01test.c", O_RDONLY);
		if(fd == -1)
		{
			perror("open error");
			return -1;
		}
 
		while(1)
		{
			memset(rcvbuf, 0, sizeof(rcvbuf));  //清空内容
			int res = read(fd, rcvbuf, sizeof(rcvbuf));
			write(1, rcvbuf, res);    //输出到终端
			if(res == 0)
			{
				break;
			}
 
			sleep(2);
		}
 
 
	}else
	{
		perror("fork error");
		return -1;
	}
 
 
	while(1);
 
	return 0;
}
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid = -1;
	int num = 520;    //父进程的资源
 
	//创建子进程
	pid = fork();
	if(pid > 0)
	{
		//父进程
		num = 1314;
		printf("父进程中num = %d, %p\n", num, &num);    //1314
 
	}else if(pid == 0)
	{
		//子进程
		printf("子进程中num = %d, %p\n", num, &num);     //520
	}else
	{
		perror("fork error");
		return -1;
	}
 
	while(1);
 
	return 0;
}
 

#include <sys/types.h>
#include <unistd.h>
 
pid_t getpid(void);
功能：获取当前进程的pid号
参数：无
返回值：成功返回当前进程的pid号，不会失败

pid_t getppid(void);
功能：获取当前进程的父进程的pid号
参数：无
返回值：成功返回当前进程的父进程pid号，不会失败       
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid = -1;
 
	//创建子进程
	pid = fork();
	if(pid > 0)
	{
		//父进程
		printf("父进程中:pid=%d, child pid=%d, parent pid=%d\n",\
				getpid(), pid, getppid());   
 
	}else if(pid == 0)
	{
		//子进程
		printf("子进程中:pid=%d, parent pid=%d\n", \
				getpid(), getppid());    
	}else
	{
		perror("fork error");
		return -1;
	}
 
	while(1);
 
	return 0;
}
 

       #include <stdlib.h>
 
       void exit(int status);
功能：刷新标准io的缓冲区后，退出进程
参数：进程退出时的状态，会将 status&0377的结果返回给父进程
        EXIT_SUCCESS（0）：表示成功退出
        EXIT_FAILURE（1）：表示失败退出
返回值：无
 
 
       #include <unistd.h>
 
       void _exit(int status);
功能：不刷新标准io的缓冲区，直接退出进程
参数：进程退出时的状态，会将 status&0377的结果返回给父进程
        EXIT_SUCCESS（0）：表示成功退出
        EXIT_FAILURE（1）：表示失败退出
返回值：无

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid = -1;
 
	//创建子进程
	pid = fork();
	if(pid > 0)
	{
		//父进程
		printf("父进程中:pid=%d, child pid=%d, parent pid=%d\n",\
				getpid(), pid, getppid());   
 
	}else if(pid == 0)
	{
		//子进程
		printf("子进程中:pid=%d, parent pid=%d\n", \
				getpid(), getppid());    
 
		sleep(3);
		
		//输出一组数据
		printf("1111111111111111111111");
		//exit(EXIT_SUCCESS);                //刷新标准io的缓冲区后退出进程
		_exit(EXIT_SUCCESS);                //不刷新标准io的缓冲区后退出进程
 
 
 
	}else
	{
		perror("fork error");
		return -1;
	}
 
	while(1);
 
	return 0;
}
 

#include <sys/types.h>
#include <sys/wait.h>
 
pid_t wait(int *wstatus);
功能：阻塞等待子进程的结束并回收子进程的资源，如果子进程不退出，则父进程会一直在该函数处阻塞
参数：接受子进程退出时的状态，一般填NULL，表示不接收
返回值：成功返回退出的子进程的pid号，失败返回-1并置位错误码

 
pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：可以阻塞也可以非阻塞形式回收子进程的资源
参数1：进程号
        >0:表示回收特定的子进程的资源（常用）
        =0：回收当前进程所在进程组中的任意一个子进程
        =-1：表示回收任意一个子进程 （常用）
        <-1:表示回收其他组（组id为pid的绝对值）中的任意一个子进程
参数2：接收子进程退出时的状态，一般填NULL，表示不接收
参数3：是否阻塞的选项
        0：表示阻塞
        WNOHANG：表示非阻塞回收
返回值：>0:表示成功回收一个子进程，返回该子进程的pid
        =0：非阻塞回收资源时，没有子进程退出，该函数返回0
        =-1：失败返回-1并置位错误码                                     
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	pid_t pid1 = -1;
	//创建出一个子进程
	pid1 = fork();
	if(pid1 == 0)
	{
		printf("我是老大\n");
		sleep(2);
		exit(EXIT_SUCCESS);
	}else if(pid1 > 0)
	{
		//创建一个子进程
		pid_t pid2 = fork();
		if(pid2 == 0)
		{
			printf("我是老二\n");
			sleep(5);
			exit(EXIT_SUCCESS);
		}else if(pid2 > 0)
		{
			printf("我是父进程,我来回收资源\n");
			wait(NULL);
			wait(NULL);
 
			printf("孩子都死了，我也不活了\n");
		}else
		{
			perror("fork error");
			return -1;
		}
	}else
	{
		perror("fork error");
		return -1;
	}
 
	return 0;
}
 

       #include <sys/types.h>
       #include <unistd.h>
 
       pid_t setsid(void);
功能：为当前进程创建一个新的会话，并将调用进程设置成会话组组长
参数：无
返回值：新会话的ID，失败返回-1并置位错误码
 
 
       #include <unistd.h>
 
       int chdir(const char *path);
功能：更改当前进程的操作目录
参数：要操作的起始目录
返回值：成功返回0，失败返回-1并置位错误码
 
       #include <sys/types.h>
       #include <sys/stat.h>
 
       mode_t umask(mode_t mask);
功能：设置当前进程创建文件的掩码的值
参数：要创建的掩码值
返回值：成功之前的掩码的值，不会失败

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//定义进程号
	pid_t pid = fork();
 
	if(pid > 0)
	{
		//父进程
		exit(EXIT_SUCCESS);
 
	
	}else if(pid == 0)
	{
		//子进程
		//将该孤儿进程，创建一个新的会话
		setsid();
 
		//更改守护进程的操作目录
		chdir("/");
 
		//给守护进程创建文件的权限为最大权限
		umask(0);
 
		//将该进程的标准输入、标准输出、标准错误重定向到文件中
		int fd = -1;
		if((fd = open("log.txt", O_RDWR|O_CREAT|O_APPEND))==-1)
		{
			perror("open error");
			return -1;
		}
 
		dup2(fd, 0);
		dup2(fd, 1);
		dup2(fd, 2);
 
		int line = 0;
 
 
		//将守护进程中的数据，存放到日志文件中
		while(1)
		{
			printf("%d:hello world\n", line++);
			fflush(stdout);
			sleep(2);
		}
 
 
 
 
		while(1);
	
	}else 
	{
		perror("fork error");
		return -1;
	}
 
	return 0;
}
 

#include <pthread.h>
 
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);   // int (int *ptr)(int,int)
功能：在当前进程中，创建一个新的线程
参数1：线程号指针，传递一个存放线程号的变量
参数2：线程属性，一般为NULL，表示使用默认的线程属性
参数3：线程体函数，是一个函数指针，需要传递一个返回值为void*类型参数为void*类型的函数名
参数4：参数3的参数，表示创建线程向新线程中传递（返回）的内容
返回值：成功返回0，失败返回一个错误码（非内核提供的错误码）
 
 
Compile and link with -pthread.     编译时需要加上-pthread
 

#include<myhead.h>
 
//定义分支线程函数体
void *task(void *arg)
{
	while(1)
	{
	printf("我是分支线程\n");
	sleep(1);
	}
 
	
}
 
 
 
/**************************主程序*****************/
int main(int argc, const char *argv[])
{
	//定义一个线程号变量
	pthread_t tid = 0;
 
	//创建出一个分支线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	printf("tid create success tid = %#lx\n", tid);
 
 
	while(1)
	{
		printf("我是主线程\n");
		sleep(1);
	}
 
	return 0;
}
 

#include<myhead.h>
 
	int sum = 520;          //定义一个全局变量
 
 
//定义分支线程函数体
void *task(void *arg)
{
 
	printf("我是分支线程\n");
 
	printf("分支线程中sum = %d\n", sum);
 
}
 
 
 
/**************************主程序*****************/
int main(int argc, const char *argv[])
{
	//定义一个线程号变量
	pthread_t tid = 0;
 
 
	//创建出一个分支线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	printf("tid create success tid = %#lx\n", tid);
	sum = 1314;
	printf("主线程中sum = %d\n", sum);         //1314
 
	while(1);
 
 
	return 0;
}
 

#include<myhead.h>
 
	int sum = 520;          //定义一个全局变量
 
 
//定义分支线程函数体
void *task(void *arg)
{
	//arg   --->void *类型的变量，不能直接解引用，因为不确定解析的字节个数
	//(int *)arg   -->将void×类型的指针，强制转换为int*类型的指针
	//*((int *)arg)  --> 指针中的前4字节解析出来的内容  520
	//*((char *)arg)   -->指针中的前1字节解析出来的内容 57
	
	printf("*((int *)arg) = %d\n", *((int *)arg) );   //输出外部传来的数据
	//printf("*((char *)arg) = %d\n", *( (char *)arg) );
 
	printf("我是分支线程\n");
 
 
	printf("分支线程中sum = %d\n", sum);
	*((int *)arg) = 666666;           //将传进来的数据更改
 
 
}
 
 
 
/**************************主程序*****************/
int main(int argc, const char *argv[])
{
	//定义一个线程号变量
	pthread_t tid = 0;
 
	int key = 12345;           //主线程中的局部变量
 
 
	//创建出一个分支线程
	if(pthread_create(&tid, NULL, task, &key) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	printf("tid create success tid = %#lx\n", tid);
	sum = 1314;
	printf("主线程中sum = %d\n", sum);         //1314
	
	sleep(1);
	printf("主线程中key = %d\n", key);         //?
	while(1);
 
 
	return 0;
}
 

#include<myhead.h>
 
	int sum = 520;          //定义一个全局变量
 
struct Info
{
	int key;
	char ch;
	double PI;
 
	double count;
};
 
 
//定义分支线程函数体
void *task(void *arg)
{
	//arg   --->void *类型的变量，不能直接解引用，因为不确定解析的字节个数
	//(int *)arg   -->将void×类型的指针，强制转换为int*类型的指针
	//*((int *)arg)  --> 指针中的前4字节解析出来的内容  520
	//*((char *)arg)   -->指针中的前1字节解析出来的内容 57
	
	//printf("*((int *)arg) = %d\n", *((int *)arg) );   //输出外部传来的数据
	//printf("*((char *)arg) = %d\n", *( (char *)arg) );
 
	printf("我是分支线程\n");
 
 
	printf("分支线程中sum = %d\n", sum);
	//*((int *)arg) = 666666;           //将传进来的数据更改
 
	printf("%d, %d, %.2lf\n", \
			(*((struct Info*)arg)).key,  ((struct Info*)arg)->ch, \
			((struct Info*)arg)->PI);
 
 
	((struct Info*)arg)->count = ((struct Info*)arg)->ch + ((struct Info*)arg)->key + ((struct Info*)arg)->PI;
 
}
 
 
 
/**************************主程序*****************/
int main(int argc, const char *argv[])
{
	//定义一个线程号变量
	pthread_t tid = 0;
 
	int key = 12345;           //主线程中的局部变量
	char ch = '\0';
	double PI = 3.14;      
	
	//定义一个结构体变量
	struct Info buf = {key, ch, PI};
 
	//创建出一个分支线程
	if(pthread_create(&tid, NULL, task, &buf) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	printf("tid create success tid = %#lx\n", tid);
	sum = 1314;
	printf("主线程中sum = %d\n", sum);         //1314
	
	sleep(1);
	printf("主线程中count = %.2lf\n", buf.count);         //?
	while(1);
 
 
	return 0;
}
 

#include <pthread.h>
 
pthread_t pthread_self(void);
功能：获取当前线程的线程号
参数：无
返回值：当前线程的线程号，不会失败

 
Compile and link with -pthread.   //编译时需要加上 -pthread
 

#include<myhead.h>
 
//定义分支线程体函数
void *task(void *arg)
{
	printf("我是分支线程：tid = %#lx\n", pthread_self());
}
 
 
 
 
 
int main(int argc, const char *argv[])
{
	//定义线程号
	pthread_t tid;
	//创建分支线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	printf("我是主线程：分支线程tid = %#lx， 自身tid = %#lx\n", tid, pthread_self());
 
 
	while(1);
 
	return 0;
}
 

       #include <pthread.h>
 
       void pthread_exit(void *retval);
功能：退出当前线程
参数：线程退出时的状态，一般填NULL
返回值：无

       #include <pthread.h>
 
       int pthread_join(pthread_t thread, void **retval);
功能：以阻塞的形式回收线程的资源
参数1：要回收的线程tid号
参数2：接收线程退出时的状态，一般填NULL
返回值：成功返回0，失败返回一个错误码
 
       #include <pthread.h>
 
       int pthread_detach(pthread_t thread);
功能：将线程设置成分离态，被设置成分离态的线程退出后，其资源由系统回收
 

#include<myhead.h>
 
//定义分支线程体函数
void *task(void *arg)
{
	//获取当前线程线程号后输出
	printf("我是分支线程：tid = %#lx\n", pthread_self());
 
	sleep(5);
 
	//exit(EXIT_SUCCESS);    //退出整个进程
	pthread_exit(NULL);
	
}
 
 
int main(int argc, const char *argv[])
{
	//定义线程号
	pthread_t tid;
	//创建分支线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	//分别输出分支线程线程号和当前线程线程号
	printf("我是主线程：分支线程tid = %#lx， 自身tid = %#lx\n", tid, pthread_self());
 
 
	//阻塞回收线程的资源
	//pthread_join(tid, NULL);
	//
	//printf("成功回收了分支线程的资源\n");
	
	//将线程设置成分离态.线程被设置成分离态后，退出时由系统回收其资源
	pthread_detach(tid);
	printf("线程已经设置成分离态了\n");
 
	sleep(8);
	printf("此时分支线程已经退出了\n");
 
 
	return 0;
}
 

       #include <pthread.h>
 
       int pthread_cancel(pthread_t thread);
功能：向一个指定线程中发送一个取消请求
参数：线程号
返回值：成功返回0，失败返回非0错误码
 
           #include <pthread.h>
 
       int pthread_setcancelstate(int state, int *oldstate);
功能：设置当前线程是否要接受其他线程的取消请求
参数1：状态
        PTHREAD_CANCEL_ENABLE：可接受取消请求（默认）
        PTHREAD_CANCEL_DISABLE：不可接收取消请求
参数2：接受当前线程旧的状态，如果不想接受。填NULL即可
返回值：成功返回0，失败返回一个错误码

#include<myhead.h>
 
//定义分支线程体函数
void *task(void *arg)
{
 
	//设置不接收取消请求
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 
	//获取当前线程线程号后输出
	printf("我是分支线程：tid = %#lx\n", pthread_self());
 
	while(1)
	{
		printf("我真的还想再活五百年\n");
		sleep(1);
	}
 
	//exit(EXIT_SUCCESS);    //退出整个进程
	pthread_exit(NULL);
	
}
 
 
int main(int argc, const char *argv[])
{
	//定义线程号
	pthread_t tid;
	//创建分支线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error\n");
		return -1;
	}
 
	//分别输出分支线程线程号和当前线程线程号
	printf("我是主线程：分支线程tid = %#lx， 自身tid = %#lx\n", tid, pthread_self());
 
 
	//阻塞回收线程的资源
	//pthread_join(tid, NULL);
	//
	//printf("成功回收了分支线程的资源\n");
	
	sleep(2);
	
	//将线程设置成分离态.线程被设置成分离态后，退出时由系统回收其资源
	pthread_detach(tid);
	printf("线程已经设置成分离态了\n");
	
	//向分支线程发送一个取消请求
	pthread_cancel(tid);
 
 
	sleep(8);
	printf("此时分支线程已经退出了\n");
 
 
	return 0;
}