linux系统编程6-守护进程、线程

进程组和会话

1、概念和特征

多个进程组成进程组，多个进程组组成会话

当父进程，创建子进程的时候，默认子进程与父进程属于同一进程组。进程组ID=-第一个进程ID(组长进程)。所以，组长进程标识:其进程组ID==其进程ID
可以使用kill -SIGKILL -进程组ID(负的)来将整个进程组内的进程全部杀死。

组长进程可以创建一个进程组，创建该进程组中的进程，然后终止。只要进程组中有一个进程存在，进程组就存在，与组长进程是否终止无关。

进程组生存期:进程组创建到最后一个进程离开(终止或转移到另一个进程组)。一个进程可以为自己或子进程设置进程组ID

2、创建会话

创建一个会话需要注意以下6点注意事项:
1.调用进程不能是进程组组长，该进程变成新会话首进程(session header)、2．该进程成为一个新进程组的组长进程。
3.需有root权限(ubuntu不需要)
4.新会话丢弃原有的控制终端，该会话没有控制终端5.该调用进程是组长进程，则出错返回
6.建立新会话时，先调用fork，父进程终止，子进程调用setsid()

三ID合一
进程id、进程组id、会话id

3、getsid函数

获取进程所属的会话ID

pid_t getsid(pid_t pid);

成功:返回调用进程的会话ID;
失败: -1，设置errno

pid为0表示察看当前进程session lD
1
2
3
4
5
6

ps ajx命令查看系统中的进程。
参数a表示不仅列当前用户的进程，也列出所有其他用户的进程，
参数x表示不仅列有控制终端的进程，也列出所有无控制终端的进程，
参数j表示列出与作业控制相关的信息。

组长进程不能成为新会话首进程，新会话首进程必定会成为组长进程。

4、setsid函数

创建一个会话，并以自己的ID设置进程组ID，同时也是新会话的ID。

pid_t setsid(void);

成功:返回调用进程的会话ID;
失败: -1，设置errno

调用了setsid函数的进程，既是新的会长，也是新的组长。
1
2
3
4
5
6

二、守护进程

1、守护进程的概念

Daemon(精灵)进程，是 Linux 中的后台服务进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。比如httpd、sshd、vsftpd、nsfd都是带d的后台运行的守护进程

Linux后台的一些系统服务进程，没有控制终端，不能直接和用户交互。不受用户登录、注销的影响，一直在运行着，他们都是守护进程。如:预读入缓输出机制的实现;ftp服务器; nfs服务器等。

创建守护进程，最关键的一步是调用setsid函数创建一个新的Session，并成为Session
Leader。

2、创建守护进程模型

	1. fork子进程，让父进程终止。

	2. 子进程调用 setsid() 创建新会话

	3. 通常根据需要，改变工作目录位置 chdir()， 防止目录被卸载。

	4. 通常根据需要，重设umask文件权限掩码，影响新文件的创建权限。  022 -- 755	0345 --- 432   r---wx-w-   422

	5. 通常根据需要，关闭/重定向 文件描述符

	6. 守护进程 业务逻辑。while（）

1
2
3
4
5
6
7
8
9
10
11
12
13

chdir(path)改变程序的工作目录

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

void sys_err(const char *str)
{
	perror(str);
	exit(1);
}

int main(int argc, char *argv[])
{
    pid_t pid;
    int ret, fd;

    pid = fork();
    if (pid > 0)                // 父进程终止
        exit(0);

    pid = setsid();           //创建新会话
    if (pid == -1)
        sys_err("setsid error");

    ret = chdir("/home/itcast/28_Linux");       // 改变工作目录位置
    if (ret == -1)
        sys_err("chdir error");

    umask(0022);            // 改变文件访问权限掩码

    close(STDIN_FILENO);    // 关闭文件描述符 0

    fd = open("/dev/null", O_RDWR);  //  fd --> 0
    if (fd == -1)
        sys_err("open error");

    dup2(fd, STDOUT_FILENO); // 重定向 stdout和stderr
    dup2(fd, STDERR_FILENO);

    while (1);              // 模拟 守护进程业务.

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

三、线程概念

1、线程

	进程：有独立的 进程地址空间。有独立的pcb。	分配资源的最小单位。

	线程：有独立的pcb。没有独立的进程地址空间。	最小单位的执行。

	ps -Lf 进程id 	---> 线程号。LWP  --》cpu 执行的最小单位。

1
2
3
4
5
6
7

进程号是cpu分配资源的最小id
线程号是cpu执行的最小单位

2、Linux内核线程实现原理

1、轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数和进程一样，都是clone
2、从内核里看进程和线程是一样的，都有各自不同的 PCB，但是线程的 PCB中指向内存资源的三级页表是相同的
3、进程可以蜕变成线程
4、线程可看做寄存器和栈的集合
5、在 linux下，线程最是小的执行单位;进程是最小的分配资源单位

3、线程共享资源

1.文件描述符表
⒉每种信号的处理方式
3.当前工作目录
4.用户ID和组ID
5.内存地址空间(.text/.data/.bss/heap/共享库)

注意，信号处理方式是共享的，但对于信号是不独立的，如果有信号传过来，谁抢到谁处理。对于mask不共享

4、线程非共享资源

1.线程id
2.处理器现场和栈指针(内核栈)
3.独立的栈空间(用户空间栈)
4.errno变量
5.信号屏蔽字6.调度优先级

5、线程优缺点

优点:
1.提高程序并发性
2.开销小
3.数据通信、共享数据方便
缺点:
1.库函数，不稳定
2.调试、编写困难、gdb不支持
3.对信号支持不好

优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。

四、线程控制原语

1、pthread_self函数获取自己的线程id

获取线程IlD。其作用对应进程中getpid()函数。

pthread_t pthread_self(void);

返回值:
  成功:0;
  失败:无!

线程ID: pthread_t类型，本质:在Linux下为无符号整数(%lu)，其他系统中可能是结构体实现线程ID是进程内部，识别标志。(两个进程间，线程ID允许相同)
1
2
3
4
5
6
7

注意:不应使用全局变量 pthread_t tid，在子线程中通过 pthread_create传出参数来获取线程ID，而应使用pthread_self。

2、pthread_create函数创建一个新线程

创建一个新线程。 其作用，对应进程中 fork()函数。

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void
*), void *arg);
返回值:
	成功:0;
	失败:错误号  Linux环境下，所有线程特点，失败均直接返回错误号。

参数:
pthread_t:当前Linux 中可理解为: typedef unsigned long int pthread_t;

参数1:传出参数，保存系统为我们分配好的线程ID
参数2:通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。
参数3:函数指针，子线程回调函数。创建成功，ptherad_create函数返回时，该函数会被自动调用。
参数4:线程主函数执行期间所使用的参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

但如果采用地址传递


由于主程序还是在使用那个i，但i是在一直变化的，所以使用地址查看值时会发生错误，因此需要使用值传递值

3、线程之间的共享

线程之间共享全局变量

【牢记】线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局变量，只能借助mmap

4、pthread_exit函数退出单个线程

将单个线程退出

void pthread_exit(void *retval);

参数: retval表示线程退出状态，通常传NULL
1
2
3

【注意】线程中，禁止使用exit函数，会导致进程内所有线程全部退出。exit(0)表示退出进程。

return:返回到调用者那里去。
pthread_exit():将调用该函数的线程退出
exit:将进程退出。

5、pthread_join函数回收线程

阻塞等待线程退出，获取线程退出状态。其作用，对应进程中 waitpid()函数。

int pthread_join(pthread_t thread, void **retval);

	成功: 0;
	失败:错误号
参数: 
  thread:线程ID  【注意】:不是指针; 
  retval:存储线程结束状态。
1
2
3
4
5
6
7

6、pthread_detach函数实现线程分离

实现线程分离

int pthread_detach(pthread_t thread);
	成功:0;
	失败:错误号
1
2
3

线程分离状态:指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。

进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。

7、pthread_cancel函数杀死线程

杀死(取消)线程 其作用，对应进程中kill(）函数。

int pthread_cancel(pthread_t thread);

  成功:0;
  失败:错误号
1
2
3
4

杀死线程不是立即完成必须要到达取消点。

取消点:是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause,close，read，write.执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。也可参阅 APUE.12.7取消选项小节。

可粗略认为一个系统调用(进入内核)即为一个取消点。如线程中没有取消点，可以在线程函数中加上pthread_testcancel函数自行设置一个取消点。

8、终止线程方式

总结:终止某个线程而不终止整个进程，有三种方法:

1. 从线程主函数return。这种方法对主控线程不适用，从main 函数 return相当于调用exit。
2. 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
3. 线程可以调用pthread_exit终止自己。

9、函数总结

	pthread_t pthread_self(void);	获取线程id。 线程id是在进程地址空间内部，用来标识线程身份的id号。

		返回值：本线程id


	检查出错返回：  线程中。

		fprintf(stderr, "xxx error: %s\n", strerror(ret));


	int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*start_rountn)(void *), void *arg); 创建子线程。

		参1：传出参数，表新创建的子线程 id

		参2：线程属性。传NULL表使用默认属性。

		参3：子线程回调函数。创建成功，ptherad_create函数返回时，该函数会被自动调用。
		
		参4：参3的参数。没有的话，传NULL

		返回值：成功：0

			失败：errno


	循环创建N个子线程：

		for （i = 0； i < 5; i++）

			pthread_create(&tid, NULL, tfn, (void *)i);   // 将 int 类型 i， 强转成 void *， 传参。	


	void pthread_exit(void *retval);  退出当前线程。

		retval：退出值。 无退出值时，NULL

		exit();	退出当前进程。

		return: 返回到调用者那里去。

		pthread_exit(): 退出当前线程。


	int pthread_join(pthread_t thread, void **retval);	阻塞 回收线程。

		thread: 待回收的线程id

		retval：传出参数。 回收的那个线程的退出值。

			线程异常借助，值为 -1。

		返回值：成功：0

			失败：errno

	int pthread_detach(pthread_t thread);		设置线程分离

		thread: 待分离的线程id

	
		返回值：成功：0

			失败：errno	

	int pthread_cancel(pthread_t thread);		杀死一个线程。  需要到达取消点（保存点）

		thread: 待杀死的线程id
		
		返回值：成功：0

			失败：errno

		如果，子线程没有到达取消点， 那么 pthread_cancel 无效。

		我们可以在程序中，手动添加一个取消点。使用 pthread_testcancel();

		成功被 pthread_cancel() 杀死的线程，返回 -1.使用pthead_join 回收。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

10、线程和进程函数对比

	线程控制原语					进程控制原语


	pthread_create()				fork();

	pthread_self()					getpid();

	pthread_exit()					exit(); 		/ return 

	pthread_join()					wait()/waitpid()

	pthread_cancel()				kill()

	pthread_detach()
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

五、线程属性

之前我们讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问题。如我们对程序的性能提出更高的要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的

下面是线程的一些属性

typedef struct{
	int etachstate;			//线程的分离状态
	int schedpolicy;		//线程调度策略
	struct sched_param schedparam;//线程的调度参数
	int inheritsched;		//线程的继承性
	int scope;  			//线程的作用域
 	size_t	guardsize;		//线程栈末尾的警戒缓冲区大小
	int	stackaddr_set;		//线程的栈设置
	void*	stackaddr;		//线程栈的位置
	size_t	stacksize;//线程栈的大小
} pthread_attr_t;
1
2
3
4
5
6
7
8
9
10
11

线程的属性值不能直接设置，应该先像上面弄mask一样，先创建一个表，然后在这个表中将属性加上，然后在创建线程时将这些属性加上

1、线程属性初始化

注意:应先初始化线程属性，再pthread_create创建线程
最后别忘了销毁这个线程属性

初始化线程属性
int pthread_attr_init(pthread_attr_t *attr);
	成功: 0;失败:错误号


销毁线程属性所占用的资源
int pthread_attr_destroy(pthread_attr_t *attr);
	成功:0;
	失败:错误号
1
2
3
4
5
6
7
8
9

2、线程的分离状态

线程的分离状态决定一个线程以什么样的方式来终止自己。
非分离状态:线程的默认属性是非分离状态,这种情况下,原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。

分离状态:分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。

应该根据自己的需要，选择适当的分离状态。

设置线程属性 分离 or 非分离

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
1

获取线程属性 分离or 非分离

int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
1

#include 
#include 
#include 
#include 
#include 

#define SIZE 0x10000

void *th_fun(void *arg)
{
	while (1) 
		sleep(1);
}

int main(void)
{
	pthread_t tid;
	int err, detachstate, i = 1;
	pthread_attr_t attr;
	size_t stacksize;   //typedef  size_t  unsigned int 
	void *stackaddr;

	pthread_attr_init(&attr);		
	pthread_attr_getstack(&attr, &stackaddr, &stacksize);
	pthread_attr_getdetachstate(&attr, &detachstate);

	if (detachstate == PTHREAD_CREATE_DETACHED)   //默认是分离态
		printf("thread detached\n");
	else if (detachstate == PTHREAD_CREATE_JOINABLE) //默认时非分离
		printf("thread join\n");
	else
		printf("thread un known\n");

	/* 设置线程分离属性 */
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	while (1) {
		/* 在堆上申请内存,指定线程栈的起始地址和大小 */
		stackaddr = malloc(SIZE);
		if (stackaddr == NULL) {
			perror("malloc");
			exit(1);
		}
		stacksize = SIZE;
	 	pthread_attr_setstack(&attr, stackaddr, stacksize);   //借助线程的属性,修改线程栈空间大小

		err = pthread_create(&tid, &attr, th_fun, NULL);
		if (err != 0) {
			printf("%s\n", strerror(err));
			exit(1);
		}
		printf("%d\n", i++);
	}

	pthread_attr_destroy(&attr);

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

六、线程使用注意事项

1. 主线程退出其他线程不退出，主线程应调用pthread_exit
2. 避免僵尸线程
   pthread_joinpthread_detach
   pthread_create指定分离属性
   被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;
3. malloc和 mmap申请的内存可以被其他线程释放
4. 应避免在多线程模型中调用fork除非，马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit（fork后子进程只有当前线程存在其他线程均不存在）
5. 信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制