9. 进程

9. 9. 守护进程

守护进程的特点

1. 后台进程
2. 生命周期：从系统开始时开启，系统关闭时结束
3. 脱离终端控制，周期执行的进程

守护进程创建步骤

1. 创建一个子进程，父进程退出，子进程变成孤儿进程，被init收养，此时变为后台进程（fork）
2. 在子进程中，创建一个新的会话，让子进程成为会话组的组长。为了让子进程完全脱离控制终端（srtsid）
3. 运行路径改为根目录，进程的运行路径不能被删除或卸载，增大子进程的权限（chdir）
4. 重设文件权限掩码，增大进程创建文件时的权限，提高灵活性（umask）
5. 关闭文件描述符，将不需要的文件描述符关闭（close）
示例

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

int main()
{
	pid_t pid = 0;
	
	// 创建子进程，父进程退出
	pid = fork();
	if(pid == EOF)
	{
		perror("fork err");
		return EOF;
	}
	if(pid == 0)
	{
		// 子进程
		// 创建会话组
		setsid();
		// 修改运行路径
		chdir("/");
		// 重设文件权限掩码
		umask(0);
		// 关闭文件描述符
		for(int i = 0; i < 3; i++)
			close(i);
		// 子进程不结束
		while(1);
	}
	else
	{
		exit(0);
	}
}

练习
练习：创建一个守护进程，循环间隔1s向文件中写入字符串 hello

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
	// 命令行判错
	if(argc != 2)
	{
		perror("argc err");
		return EOF;
	}
	
	pid_t pid = 0;
	int fd = -1;
	
	// 打开文件
	fd = open(argv[1], O_WRONLY | O_APPEND | O_CREAT, 0666);
	if(fd == -1)
	{
		perror("open err");
		return EOF;
	}
	
	// 创建子进程，父进程退出
	pid = fork();
	if(pid == EOF)
	{
		perror("fork err");
		return EOF;
	}
	if(pid == 0)
	{
		// 子进程
		// 创建会话组
		setsid();
		// 修改运行路径
		chdir("/");
		// 重设文件权限掩码
		umask(0);
		// 关闭文件描述符
		for(int i = 0; i < 3; i++)
			close(i);
		// 子进程不结束
		while(1)
		{
			sleep(1);
			write(fd, "hello\n", 6);
		}
	}
	else
	{
		exit(0);
	}
}

10. 线程

10.1. 线程的概念

 线程是一个轻量型的进程，为了提高系统的性能引入线程，线程和进程都参与CPU的调度

10.2. 进程和线程的区别

共性：都为操作系统提供并发执行的能力

不同点	线程	进程
资源和调度	系统调度的最小单位	资源分配的最小单位
地址空间	同一个进程创建的所有 线程共享进程资源	地址空间相互独立
相互通信	相对简单 全局变量即可实现 需要考虑临界资源	比较复杂 借助进程间的通信机制
安全性	相对较差 进程结束时会导致所有线程退出	相对更安全

10.2. 线程资源

共享资源：
 可执行的指令，静态的数据，进程中打开的文件描述符，信号处理函数。当前的工作目录，用户的ID，用户的组ID
私有资源：
 线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈、错误号 (errno)、信号掩码和优先级、执行状态和属性
线程标识：
主线程的 TID 和 PID 是相同的，每个子线程有自己独立的 TID，但它们都共享相同的 PID

10.3. 线程的函数接口

1. pthread_create-创建线程

 #include <pthread.h>
int pthread_create(pthread_t  *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

 功能：创建线程
 参数：
  pthread_t *thread：线程标识，成功创建线程后，pthread_create 会将新线程的 ID 写入 thread 指向的内存位置。
  const pthread_attr_t *attr：线程属性， NULL：代表设置默认属性
  void *(*start_routine)：函数名，代表线程函数，指向一个函数的指针，这个函数就是线程的执行体（也就是线程的入口函数）。该函数必须符合 void *(*start_routine)(void *) 的原型，即接受一个 void * 类型的参数，并返回一个 void * 类型的值。
  void *arg：线程函数传递的参数，不传参为NULL
 返回值：成功返回0，失败更新errno

1. CPU调度线程也是随机的
2. 编译时需要加上-lpthread
   示例：

#include <stdio.h>
#include <pthread.h>
// 线程函数
void *pthreadFun(void *arg)
{
	printf("子线程结束\n");
}
int main()
{
	pthread_t tid = 0;
	// 创建线程
	if(pthread_create(&tid, NULL, pthreadFun, NULL))
	{
		printf("create err\n");
		return EOF;
	}
	printf("主线程执行……\n");
    sleep(2);
	printf("主线程执行结束\n");
	return 0;
}

3. 传参

void *pthreadFun(void *arg)
{
	int num = *((int *)arg);
	printf("子线程结束\n");
}
int main()
{
	int a = 121;
	int *p = &a;
}

线程函数和普通函数的区别

1. 普通函数是顺序执行的，手动调用函数，执行函数操作，线程函数在创建的线程中并发执行，不会影响主程序的运行。
2. 普通函数同步执行，线程函数异步执行
3. 存储位置不一样，普通函数存放在当前线程的栈区空间，线程函数共享进程的全局变量和堆空间。

2. pthread_exit

#include <pthread.h>
void pthread_exit(void *retval);

 功能：退出进程
 参数：void *retval任意类型数据，一般为NULL
 返回值：空

3.线程资源回收函数

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);

 功能：用于等待一个指定的线程结束，阻塞函数
 参数：
  thread：创建线程对象
  void **retval：指针*retval指向线程返回的参数，一般是NULL
 返回值：成功返回0，失败errno

#include <pthread.h>
int pthread_detach(pthread_t thread);

 功能：让线程结束时自动回收线程资源,让线程和主线程分离
 参数：pthread_t thread：线程ID
 返回值：成功返回0，失败EOF

join和detach的区别

获取线程号（pthread_self）

#include <pthread.h>
pthread_t pthread_self(void);

 功能：获取线程号
 参数：无
 返回值：成功返回线程ID

10.4. 线程间的通信机制

概念

 线程之间是很容易进行通信的，能够通过全局变量实现数据的共享和交换，也就是通过访问临界资源，但是多个线程在同时访问共享数据的对象时需要引入同步和互斥机制。
 临界资源：一次只允许一个线程访问的资源叫临界资源

同步机制

 同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情

信号量

Linux中信号量分三类

1. 内核信号量：由内核控制路径使用
2. Posix信号量
    1. 无名信号量：存储在内存中，通常在线程间或父子进程间使用
   函数接口：sem_init\sem_wait\sem_post
    2. 有名信号量：存储在文件中，在进程间线程间都可以使用
   函数接口：sem_open\sem_wait\sem_post\sem_close
3. System V信号量：是信号量的集合，叫信号灯集，属于IPC对象
   函数接口：semget\semctl\semop

无名信号量

 信号量：通过信号量实现同步操作，由信号量决定线程是继续运行还是阻塞等待。
 信号量代表的是某一类资源，它的值表示系统中该资源的数量，信号量>0的话，表示有资源可以使用，可以申请到资源，继续执行程序，信号量<= 0的话，表示没有资源可以使用，无法申请到资源，阻塞。
 信号量是一个受保护的量，只能通过函数接口访问
函数接口
初始化信号量：sem_init()
P操作，申请资源：sem_wait() 资源-1
V操作，释放资源：sem_post() 资源+1
注意：信号量是一个非负的整数，所以一定是 (>=0)

无名信号量函数接口

头文件

#include <semaphore.h>

sem_init()

#include <semaphore.h>
int  sem_init(sem_t *sem,  int pshared,  unsigned int value);

 功能：信号量初始化
 参数：
  sem_t *sem初始化的信号量
  int pshared信号量共享范围（0：线程间，1：进程间）
  unsigned int value信号量的初值
 返回值：成功0，失败EOF
sem_wait()

#include <semaphore.h>
int  sem_wait(sem_t *sem) 

 功能：申请资源，p操作
 参数：sem_t *sem信号量
 返回值：成功0，失败EOF
注意：函数执行时，信号量大于0，标识有资源可用；信号量为0时，表示没有资源可用，此时程序在此阻塞
sem_post()

#include <semaphore.h>
int  sem_post(sem_t *sem);

 功能：释放资源，V操作
 参数：sem_t *sem信号量
 返回值：成功0，失败EOF
sem_getvalue

 int sem_getvalue(sem_t *sem, int *sval);

 功能：获取信号量的值
 参数：
  sem_t *sem信号量对象
  int *sval信号量的值存放的变量（&）
 返回值：成功0，失败errno
sem_destroy

int sem_destroy(sem_t *sem);

 功能：销毁信号量
 参数：sem_t *sem信号量对象
 返回值：成功返回0，失败errno

互斥

 互斥：多个线程在访问临界资源时，同一时间只能一个线程进行访问

互斥锁

 互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。

互斥锁的函数接口

pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t  *mutex, pthread_mutexattr_t *attr);

 功能：初始化互斥锁
 参数：
  pthread_mutex_t *mutex互斥锁
  pthread_mutexattr_t *attr一般为NULL默认属性
 返回值：成功返回0，失败返回EOF
pthread_mutex_lock

int  pthread_mutex_lock(pthread_mutex_t *mutex);

 功能：申请互斥锁
 参数：pthread_mutex_t *mutex互斥锁
 返回值：成功返回0，失败返回EOF
pthread_mutex_unlock

int  pthread_mutex_unlock(pthread_mutex_t *mutex)；

 功能：释放互斥锁
 参数：pthread_mutex_t *mutex互斥锁
 返回值：成功返回0，失败返回EOF
pthread_mutex_destroy

int  pthread_mutex_destroy(pthread_mutex_t  *mutex);

 功能：销毁互斥锁
 参数：pthread_mutex_t *mutex互斥锁
 返回值：成功返回0，失败返回EOF

条件变量

一般与互斥锁一起用，实现同步机制

条件变量函数接口

pthread_cond_init

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);

 功能：初始化条件变量
 参数：
  pthread_cond_t *restrict cond条件变量对象
  const pthread_condattr_t *restrict attr为NULL，默认变量
 返回值：成功：0 失败：非0
pthread_cond_wait

int pthread_cond_wait(pthread_cond_t *restrict cond,    pthread_mutex_t *restrict mutex);

 功能：等待信号的产生
 参数：
  pthread_cond_t *restrict cond条件变量对象
  pthread_mutex_t *restrict mutex互斥锁
 返回值：成功：0 失败：非0
注意：没有信号的时候函数会阻塞，同时解锁；等到条件产生，函数会结束结束阻塞同时上锁
pthread_cond_signal

int pthread_cond_signal(pthread_cond_t *cond);

 功能：产生条件变量信号
 参数：pthread_cond_t *cond条件变量
 返回值：成功：0，失败：非0
注意：一定要pthread_cond_wait先执行，再产生条件
pthread_cond_destroy

int pthread_cond_destroy(pthread_cond_t *cond);

 功能：将条件变量销毁
 参数：pthread_cond_t *cond条件变量
 返回值：成功：0，失败：非0