linux-守护进程和线程
2024-05-16 02:33:55
linux-守护进程和线程
- 学习目标
- 1 守护进程
- 1.1 守护进程介绍
- 1.2 进程组和会话
- 1.3 创建守护进程的模型
- 1.4 练习
- 2 线程
- 2.1 什么是线程
- 2.2 线程共享资源
- 2.3 线程非共享资源（重点）（重点）
- 2.4 线程优、缺点
- 2.5 pthread_create函数
- 2.5.1练习题
- 2.6 pthread_exit函数（重点）
- 2.6.1练习：编写程序测试pthread_exit函数使一个线程退出。
- 2.7 pthread_join函数（重点）
- 2.7.1练习：编写程序，使主线程获取子线程的退出状态。
- 2.8 pthread_detach函数（重点）
- 2.8.1练习：编写程序，在创建线程之后设置线程的分离状态。
- 2.9 pthread_cancel函数（重点）
- 2.9.1 练习：编写程序，让主线程取消子线程的执行。
- 2.10 pthread_equal函数（重点）
- 2.11 进程函数和线程函数比较
- 3 线程属性
- 3.1练习：编写程序，创建一个分离属性的线程。
- 4 线程同步
- 4.1 线程同步的概念（重要）
- 4.2 线程同步的例子（重要）
- 4.3 互斥锁主要相关函数（重要）
- 4.3.1 pthread_mutex_t类型
- 4.3.2 pthread_mutex_init函数
- 4.3.3 pthread_mutex_destroy函数
- 4.3.4 pthread_mutex_lock函数
- 4.3.5 pthread_mutex_unlock函数
- 4.3.6 pthread_mutex_trylock函数
- 4.4 加锁和解锁
- 4.4.1练习：使用互斥锁解决两个线程数数不一致的问题。
学习目标
- 说出守护进程的特点
- 独立完成守护进程的创建
- 独立实现多个线程的创建
- 独立实现线程的退出和资源回收
- 理解线程同步的思想
1 守护进程
1.1 守护进程介绍
Daemon(精灵)进程，是Linux中的后台服务进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字，如vsftpd
Linux后台的一些系统服务进程，没有控制终端，不能直接和用户交互。不受用户登录、注销的影响，一直在运行着，他们都是守护进程。如：预读入缓输出机制的实现；ftp服务器；nfs服务器等。
总结守护进程的特点：
- Linux后台服务进程
- 独立于控制终端
- 周期性的执行某种任务
- 不受用户登陆和注销的影响
- 一般采用以d结尾的名字
1.2 进程组和会话
进程组
- 进程组是一个或者多个进程的集合，每个进程都属于一个进程组，引入进程组是为了简化对进程的管理。当父进程创建子进程的时候，默认子进程与父进程属于同一个进程组。
进程组ID==第一个进程ID（组长进程）。如父进程创建了多个子进程，父进程和多个子进程同属于一个组，而由于父进程是进程组里的第一个进程，所以父进程就是这个组的组长, 组长ID==父进程ID。 - 可以使用kill -SIGKILL -进程组ID(负的)来将整个进程组内的进程全部杀死。
- 只要进程组中有一个进程存在，进程组就存在，与组长进程是否终止无关。
- 进程组生存期：从进程组创建到最后一个进程离开
会话
- 一个会话是一个或多个进程组的集合。
- 创建会话的进程不能是进程组组长
- 创建会话的进程成为一个进程组的组长进程，同时也成为会话的会长。
- 需要有root权限（ubuntu不需要）
- 新创建的会话丢弃原有的控制终端
- 建立新会话时，先调用fork, 父进程终止，子进程调用setsid函数
可以使用ps ajx来查看进程组ID和会话ID
- 可以fork出几个子进程，然后查看进程组ID和会话ID
进程组和会话的关系图
1.3 创建守护进程的模型
- fork子进程，父进程退出
子进程继承了父进程的进程组ID, 但具有一个新的进程ID,这样就保证了子进程不是一个进程组的组长ID,这对于下面要做的setsid函数的调用是必要的前提条件 - 子进程调用setsid函数创建新会话
- 调用这个函数以后
- 该进程成为新会话的首进程，是会话的会长
- 成为一个新进程组的组长进程，是进程组组长
- 不受控制终端的影响
- 改变当前工作目录chdir
- 如：a.out在U盘上，启动这个程序，这个程序的当前的工作目录就是这个u盘，如果u盘拔掉后进程的当前工作目录将消失，a.out将不能正常工作。
- 重设文件掩码 mode & ~umask
- 子进程会继承父进程的掩码
- 增加子进程程序操作的灵活性
- umask(0000);
- 关闭文件描述符
- 守护进程不受控制终端的影响所以可以关闭，以释放资源
- close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
- 执行核心工作
- 守护进程的核心代码逻辑
1.4 练习
编写一个守护进程，每隔2S钟获取一次系统时间，并将这个时间写入磁盘文件。
分析：首先要按照1.3介绍的守护进行的步骤创建一个守护进程。题目要求每隔2S钟，所以需要一个定时器，2S钟触发一次，需要调用setitimer函数创建一个定时器，并且要捕获SIGALRM信号，然后在SIGALRM信号处理函数里面完成获取系统时间，然后将时间写入文件。
用到的主要知识点：
- 创建守护进程的模型
- setitimer函数的使用
- sigaction函数
- 文件I/O操作
- 获取系统时间函数time，将time_t类型转换为字符串ctime函数
/** @Descripttion: 创建守护进程* @version: * @Author: Lzy* @Date: 2021-07-23 19:10:20* @LastEditors: Lzy* @LastEditTime: 2021-07-23 19:27:06*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>void sighandler(int signum)
{//打开文件int fd = open("time.log",O_RDWR|O_CREAT|O_APPEND,0777);if (fd < 0){return ;}//获取当前系统时间time_t t = time(NULL);char *p = ctime(&t);//将时间写入文件中write(fd,p,strlen(p));//关闭文件close(fd);}int main(int argc, char **argv)
{pid_t pid = fork();if (pid < 0 || pid > 0){exit(1);}//子进程创建setsid函数创建会话setsid();//改变目录chdir("/home/lzy/system_programming/day8/");//改变掩码umask(0000);//关闭标准输入、输出和错误文件描述符close(STDIN_FILENO);close(STDOUT_FILENO);close(STDERR_FILENO);//核心操作//注册信号处理函数// int sigaction(int signum, const struct sigaction *act,// struct sigaction *oldact);struct sigaction act;act.sa_handler = sighandler;act.sa_flags = 0;sigemptyset(&act.sa_mask);sigaction(SIGALRM, &act, NULL);// 设置2S周期性信号// int setitimer(int which, const struct itimerval *new_value,// struct itimerval *old_value);struct itimerval tm;tm.it_interval.tv_sec = 2;tm.it_interval.tv_usec = 0;tm.it_value.tv_sec = 2;tm.it_value.tv_usec = 0;setitimer(ITIMER_REAL, &tm, NULL);//测试守护进程是否在终端打印信息printf("this is daemon\n");while(1){sleep(1);}return 0;}
2 线程
2.1 什么是线程
轻量级的进程（LWP：light weight process），在Linux环境下线程的本质仍是进程。
进程：拥有独立的地址空间，拥有PCB，相当于独居。
线程：有PCB，但没有独立的地址空间，多个线程共享进程空间，相当于合租。
在Linux操作系统下：
线程：最小的执行单位
进程：最小分配资源单位，可看成是只有一个线程的进程。线程的特点
- 类Unix系统中，早期是没有“线程”概念的，80年代才引入，借助进程机制实现出了线程的概念。因此在这类系统中，进程和线程关系密切。
- 线程是轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数和进程一样，都是clone
- 从内核里看进程和线程是一样的，都有各自不同的PCB.
- 进程可以蜕变成线程
- 在linux下，线程最是小的执行单位；进程是最小的分配资源单位
察看指定线程的LWP号：ps -Lf pid
实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数 clone。
- 如果复制对方的地址空间，那么就产出一个“进程”；
- 如果共享对方的地址空间，就产生一个“线程”。
so：Linux内核是不区分进程和线程的, 只在用户层面上进行区分。
所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。
2.2 线程共享资源
- 文件描述符表
- 每种信号的处理方式
- 当前工作目录
- 用户ID和组ID
- 内存地址空间 (.text/.data/.bss/heap/共享库)
2.3 线程非共享资源（重点）（重点）
- 线程id
- 处理器现场和栈指针(内核栈)
- 独立的栈空间(用户空间栈)
- errno变量（重点）
- 信号屏蔽字
- 调度优先级
2.4 线程优、缺点
- 优点：
- 提高程序并发性
- 开销小
- 数据通信、共享数据方便
- 缺点：
- 库函数，不稳定
- gdb调试、编写困难
- 对信号支持不好
优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。
2.5 pthread_create函数
- 函数作用：创建一个新线程
- 函数原型：
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *),void *arg); - 返回值
- 成功，返回0
- 失败，返回错误号
- 函数参数：
- pthread_t：传出参数，保存系统为我们分配好的线程ID
当前Linux中可理解为：typedef unsigned long int pthread_t。 - attr：通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。
- start_routine：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
- arg：线程主函数执行期间所使用的参数。
- pthread_t：传出参数，保存系统为我们分配好的线程ID
- 注意点
- 由于pthread_create的错误码不保存在errno中，因此不能直接用perror()打印错误信息，可以先用strerror()把错误码转换成错误信息再打印。
- 如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，我们在main函数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新创建的线程执行，下一节我们会看到更好的办法。
2.5.1练习题
1 编写程序创建一个线程。
2 编写程序创建一个线程，并给线程传递一个int参数
3 编写程序创建一个线程，并给线程传递一个结构体参数。
/** @Descripttion: 创建子线程:传参结构体* @version: * @Author: Lzy* @Date: 2021-07-23 20:41:47* @LastEditors: Lzy* @LastEditTime: 2021-07-23 21:26:43*/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>struct student{int age;char name[64];
};void *mythread(void *arg)
{struct student *p = (struct student *)arg;printf("age == [%d],name == [%s]\n", p->age, p->name);printf("mythread id == [%ld],pid == [%d]\n",pthread_self(),getpid());return arg;
}int main(int argc,char ** argv){// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);struct student st1;memset(st1,0,sizeof(struct st1));st1.age = 12;strcpy(st1.name,"lzy");pthread_t thread;int ret = pthread_create(&thread,NULL,mythread,&st1);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());//防止线程还没起来，主线程就结束退出。sleep(1);return 0;}
4 编写程序，主线程循环创建5个子线程，并让子线程判断自己是第几个子线程。
练习4分析：最后每个子线程打印出来的值并不是想象中的值，比如都是5，分析其原因：
在创建子线程的时候使用循环因子作为参数传递给子线程，这样主线程和多个子线程就会共享变量i（变量i在main函数中定义，在整个进程都一直有效）所以在子线程看来变量i是合法的栈内存空间。
那么为什么最后每个子线程打印出来的值都是5呢?
是由于主线程可能会在一个cpu时间片内连续创建了5个子线程，此时变量i的值变成了5，当主线程失去cpu的时间片后，子线程得到cpu的时间片，子线程访问的是变量i的内存空间的值，所以打印出来值为5。
主线程和子线程共享同一块内存空间
主线程和子线程分时使用cpu资源
解决办法：不能使多个子线程都共享同一块内存空间，应该使每个子线程访问不同的内存空间，可以在主线程定义一个数组：int arr[5];，然后创建线程的时候分别传递不同的数组元素，这样每个子线程访问的就是互不相同的内存空间，这样就可以打印正确的值。
如下图：
多个子线程各自访问不同的内存空间
/** @Descripttion: 主线程循环创建5个子线程，并让子线程判断自己是第几个子线程。不让线程公用一个修改数据的地址。* @version: * @Author: Lzy* @Date: 2021-07-23 20:41:47* @LastEditors: Lzy* @LastEditTime: 2021-07-23 21:52:49*/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>void *mythread(void *arg)
{printf("[%d]:cild thread ,id == [%ld],pid == [%d]\n",*(int*)arg,pthread_self(),getpid());return arg;
}
int main(int argc,char ** argv){// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);int i = 0;int n = 5;pthread_t thread[5];int arr[5];for (size_t i = 0; i < n; i++){arr[i] = i;int ret = pthread_create(&thread[i],NULL,mythread,&arr[i]);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}// sleep(1);}printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());//防止线程还没起来，主线程就结束退出。sleep(1);return 0;
}
根据测试程序还可以得出结论：
- 如果主线程早于子线程退出，则子线程可能得不到执行，因为主线程退出，整个进程空间都会被回收，子线程没有了生存空间，所以也就得不到执行。
- 线程之间（包含主线程和子线程）可以共享同一变量，包含全局变量或者非全局变量（但是非全局变量必须在其有效的生存期内）
2.6 pthread_exit函数（重点）
在线程中禁止调用exit函数，否则会导致整个进程退出，取而代之的是调用pthread_exit函数，这个函数是使一个线程退出，如果主线程调用pthread_exit函数也不会使整个进程退出，不影响其他线程的执行。
- 函数描述：将单个线程退出
- 函数原型：void pthread_exit(void *retval);
- 函数参数：retval表示线程退出状态，通常传NULL
另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了，栈空间就会被回收。
2.6.1练习：编写程序测试pthread_exit函数使一个线程退出。
通过程序测试得知，pthread_exit函数只是使一个线程退出，假如子线程里面调用了exit函数，会使整个进程终止；如果主线程调用了pthread_exit函数，并不影响子线程，只是使主线程自己退出。
2.7 pthread_join函数（重点）
- 函数描述：阻塞等待线程退出，获取线程退出状态。其作用，对应进程中的waitpid() 函数。
- 函数原型：int pthread_join(pthread_t thread, void **retval);
- 函数返回值：
- 成功：0；
- 失败：错误号
- 函数参数：
- thread：线程ID
- retval：存储线程结束状态，整个指针和pthread_exit的参数是同一块内存地址。
2.7.1练习：编写程序，使主线程获取子线程的退出状态。
一般先定义void *ptr; 然后pthread_join(threadid, &ptr);
/************************************************************************************** @Descripttion : 编写程序，使主线程获取子线程的退出状态。* @version : 1.0* @Author : lzy* @Date : 2021-07-23 22:16:08* @LastEditors : your name* @LastEditTime : 2021-07-24 16:14:05* @FilePath : /day8/pthread_join.c* @Copyright 2021 liuziyan, All Rights Reserved. *************************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>struct student{int age;char name[64];
};
struct student st1;/************************************************************************************** Descripttion : * name : liuziyan* param {void} *arg* return {*}* version : 1.0* Date : 2021-07-24 11:28:22*************************************************************************************/
void *mythread(void *arg)
{struct student *p = (struct student *)arg;memset(p, 0, sizeof(struct student));p->age = 12;strcpy(p->name,"lzy");printf("age == [%d],name == [%s]\n", p->age, p->name);printf("mythread id == [%ld],pid == [%d]\n",pthread_self(),getpid());printf("address == [%p]\n",p);pthread_exit(p);
}int main(int argc,char ** argv){// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);pthread_t thread;int ret = pthread_create(&thread,NULL,mythread,&st1);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());void *p = NULL;pthread_join(thread,&p);struct student *pt = (struct student*)p;printf("cild exit status == [%d],[%s],[%p]\n",pt->age,pt->name,pt);return 0;}
2.8 pthread_detach函数（重点）
线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。
进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。
也可使用 pthread_create函数参2(线程属性)来设置线程分离。pthread_detach函数是在创建线程之后调用的。
- 函数描述：实现线程分离
- 函数原型：int pthread_detach(pthread_t thread);
- 函数返回值
- 成功：0；
- 失败：错误号
一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
2.8.1练习：编写程序，在创建线程之后设置线程的分离状态。
说明：如果线程已经设置了分离状态，则再调用pthread_join就会失败，可用这个方法验证是否已成功设置分离状态。
/************************************************************************************** @Descripttion : 调用pthread_detach()设置线程分离状态，* 若再调用pthread_join就会失败，* 可用这个方法验证是否已成功设置分离状态。* @version : 1.0* @Author : lzy* @Date : 2021-07-23 22:16:08* @LastEditors : your name* @LastEditTime : 2021-07-24 16:33:56* @FilePath : /day8/pthread_detach.c* @Copyright 2021 liuziyan, All Rights Reserved. *************************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>struct student{int age;char name[64];
};
struct student st1;/************************************************************************************** Descripttion : * name : liuziyan* param {void} *arg* return {*}* version : 1.0* Date : 2021-07-24 11:28:22*************************************************************************************/
void *mythread(void *arg)
{printf("mythread id == [%ld],pid == [%d]\n",pthread_self(),getpid());pthread_exit(NULL);
}int main(int argc,char ** argv){// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);pthread_t thread;int ret = pthread_create(&thread,NULL,mythread,&st1);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());//设置线程为分离属性pthread_detach(thread);//子线程设置为分离属性，则ptread_join直接返回错误，不再阻塞ret = pthread_join(thread,NULL);if(ret != 0){printf("pthread_join error,[%s]\n", strerror(ret));return -1;}return 0;
}
2.9 pthread_cancel函数（重点）
- 函数描述：杀死(取消)线程。其作用，对应进程中 kill() 函数。
- 函数原型：int pthread_cancel(pthread_t thread);
- 函数返回值
- 成功：0；
- 失败：错误号
【注意】：线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。
类似于玩游戏存档，必须到达指定的场所(存档点，如：客栈、仓库、城里等)才能存储进度。杀死线程也不是立刻就能完成，必须要到达取消点。
取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write… 执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。可粗略认为一个系统调用(进入内核)即为一个取消点。还以通过调用pthread_testcancel函数设置一个取消点。函数原型：void pthread_testcancel(void);
2.9.1 练习：编写程序，让主线程取消子线程的执行。
先测试一下没有取消点看看能否使线程取消；然后调用pthread_testcancel设置一个取消点，看看能够使线程取消。
/************************************************************************************** @Descripttion : pthread_cancel()取消线程，并直接退出该线程，不再运行！pthread_testcancel设置取消点。* 线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。* 如果错过了取消点，即使取消线程也没效果。* @version : 1.0* @Author : lzy* @Date : 2021-07-23 22:16:08* @LastEditors : your name* @LastEditTime : 2021-07-24 17:00:55* @FilePath : /day8/pthread_cancel.c* @Copyright 2021 liuziyan, All Rights Reserved. *************************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>struct student{int age;char name[64];
};
struct student st1;/************************************************************************************** Descripttion : * name : liuziyan* param {void} *arg* return {*}* version : 1.0* Date : 2021-07-24 11:28:22*************************************************************************************/
void *mythread(void *arg)
{while(1){ int a;int b;//设置取消点pthread_testcancel();}printf("mythread id == [%ld],pid == [%d]\n",pthread_self(),getpid());pthread_exit(NULL);
}int main(int argc,char ** argv){// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);pthread_t thread;int ret = pthread_create(&thread,NULL,mythread,&st1);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());//取消线程pthread_cancel(thread);ret = pthread_join(thread,NULL);if(ret != 0){printf("pthread_join error,[%s]\n", strerror(ret));return -1;}return 0;
}
2.10 pthread_equal函数（重点）
- 函数描述：比较两个线程ID是否相等。
- 函数原型：int pthread_equal(pthread_t t1, pthread_t t2);
注意：这个函数是为了以能够扩展使用的， 有可能Linux在未来线程ID pthread_t 类型被修改为结构体实现。
2.11 进程函数和线程函数比较
| 进程 | 线程 |
|---|---|
| fork | pthread_create |
| exit | pthread_exit |
| wait/waitpid | pthread_join |
| kill | pthread_cancel |
| getpid | pthread_self |
3 线程属性
linux下线程的属性是可以根据实际项目需要，进行设置，之前讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问题，如果对程序的性能提出更高的要求，则需要设置线程属性，本节以设置线程的分离属性为例讲解设置线程属性。
线程的分离状态决定一个线程以什么样的方式来终止自己，有两种状态：
- 非分离状态：线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
- 分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。
设置线程属性分为以下步骤
第1步：定义线程属性类型类型的变量 pthread_attr_t attr;
第2步：对线程属性变量进行初始化 int pthread_attr_init (pthread_attr_t* attr);
第3步：设置线程为分离属性int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
- attr: 线程属性
- detachstate:
- PTHREAD_CREATE_DETACHED(分离)
- PTHREAD_CREATE_JOINABLE（非分离)
第4步：释放线程属性资源int pthread_attr_destroy(pthread_attr_t *attr);
参数：线程属性
3.1练习：编写程序，创建一个分离属性的线程。
验证：设置为分离属性的线程是不能够被pthread_join函数回收的，可以通过调用pthread_join函数测试该线程是否已经是分离属性的线程。
/************************************************************************************** @Descripttion : * @version : 1.0* @Author : liuziyan* @Date : 2021-07-24 17:08:45* @LastEditors : Lzy* @LastEditTime : 2021-07-24 17:14:54* @FilePath : /day8/pthread_detached.c* @Copyright 2021 liuziyan, All Rights Reserved. *************************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>void *mythread(void *arg)
{ printf("mythread id == [%ld],pid == [%d]\n",pthread_self(),getpid());sleep(2);pthread_exit(NULL);
}int main(int argc,char ** argv){//创建线程为分离属性pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);pthread_t thread;int ret = pthread_create(&thread,&attr,mythread,NULL);if (ret < 0){printf("pthread_create error,[%s]\n", strerror(ret));return -1;}//释放线程属性pthread_attr_destroy(&attr);printf("main thread id == [%ld],pid == [%d]\n",pthread_self(),getpid());//子线程设置为分离属性，则ptread_join直接返回错误，不再阻塞ret = pthread_join(thread,NULL);if(ret != 0){printf("pthread_join error,[%s]\n", strerror(ret));return -1;}return 0;
}
4 线程同步
4.1 线程同步的概念（重要）
线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。
4.2 线程同步的例子（重要）
创建两个线程，让两个线程共享一个全局变量int number， 然后让每个线程数5000次数，看最后打印出这个number值是多少？
线程A代码片段：
线程B代码片段：
- 代码片段说明
- 代码中使用调用usleep是为了让两个子线程能够轮流使用CPU，避免一个子线程在一个时间片内完成5000次数数。
- 对number执行++操作，使用了中间变量cur是为了尽可能的模拟cpu时间片用完而让出cpu的情况。
- 测试结果
- 经过多次测试最后的结果显示，有可能会出现number值少于5000*2=10000的情况。
- 分析原因
- 假如子线程A执行完了cur++操作，还没有将cur的值赋值给number失去了cpu的执行权，子线程B得到了cpu执行权，而子线程B最后执行完了number=cur，而后失去了cpu的执行权；此时子线程A又重新得到cpu的执行权，并执行number=cur操作，这样会把线程B刚刚写回number的值被覆盖了，造成number值不符合预期的值。
- 数据混乱的原因
- 资源共享（独享资源则不会）
- 调度随机（线程操作共享资源的先后顺序不确定）
- 线程间缺乏必要的同步机制。
以上3点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。
- 如何解决问题
- 原子操作的概念
原子操作指的是该操作要么不做，要么就完成。 - 使用互斥锁解决同步问题
使用互斥锁其实是模拟原子操作，互斥锁示意图：
- 原子操作的概念
Linux中提供一把互斥锁mutex（也称之为互斥量）。每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
资源还是共享的，线程间也还是竞争的，但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。
线程1访问共享资源的时候要先判断锁是否锁着，如果锁着就阻塞等待；若锁是解开的就将这把锁加锁，此时可以访问共享资源，访问完成后释放锁，这样其他线程就有机会获得锁。
应该注意：图中同一时刻，只能有一个线程持有该锁，只要该线程未完成操作就不释放锁。
使用互斥锁之后，两个线程由并行操作变成了串行操作，效率降低了，但是数据不一致的问题得到解决了。
4.3 互斥锁主要相关函数（重要）
4.3.1 pthread_mutex_t类型
- 其本质是一个结构体，为简化理解，应用时可忽略其实现细节，简单当成整数看待。
- pthread_mutex_t mutex; 变量mutex只有两种取值1、0。
4.3.2 pthread_mutex_init函数
- 函数描述：初始化一个互斥锁(互斥量) —> 初值可看作1
- 函数原型：
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); - 函数参数
- mutex：传出参数，调用时应传 &mutex
- attr：互斥锁属性。是一个传入参数，通常传NULL，选用默认属性(线程间共享)。
restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改互斥量mutex的两种初始化方式：
静态初始化：如果互斥锁 mutex 是静态分配的（定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。<fontpthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER;
动态初始化：局部变量应采用动态初始化。pthread_mutex_init(&mutex, NULL);
4.3.3 pthread_mutex_destroy函数
- 函数描述：销毁一个互斥锁
- 函数原型：
int pthread_mutex_destroy(pthread_mutex_t *mutex); - 函数参数
- mutex—互斥锁变量
4.3.4 pthread_mutex_lock函数
- 函数描述：对互斥所加锁，可理解为将mutex–，如果在加锁则会阻塞一直等待解锁。
- 函数原型：int pthread_mutex_lock(pthread_mutex_t *mutex);
- 函数参数
- mutex—互斥锁变量
4.3.5 pthread_mutex_unlock函数
- 函数描述：对互斥所解锁，可理解为将mutex ++
- 函数原型：int pthread_mutex_unlock(pthread_mutex_t *mutex);
4.3.6 pthread_mutex_trylock函数
- 函数描述：尝试加锁
- 函数原型：int pthread_mutex_trylock(pthread_mutex_t *mutex);
- 函数参数
- mutex—互斥锁变量
4.4 加锁和解锁
- lock尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
- unlock主动解锁函数，同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。
4.4.1练习：使用互斥锁解决两个线程数数不一致的问题。
代码片段：在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”应越小越好。
总结：使用互斥锁之后，两个线程由并行变为了串行，效率降低了，但是可以使两个线程同步操作共享资源，从而解决了数据不一致的问题。
/************************************************************************************** @Descripttion : 对堆区数据进行加锁，避免同时访问造成数据丢失。* @version : 1.0* @Author : liuziyan* @Date : 2021-07-24 17:42:54* @LastEditors : Lzy* @LastEditTime : 2021-07-24 18:17:14* @FilePath : /day8/pthread_mutex.c* @Copyright 2021 liuziyan, All Rights Reserved. *************************************************************************************/#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>#define count 200000
int number = 0;
pthread_mutex_t mutex;void *mythread1(void *arg)
{int i = 0, n = 0;for (size_t i = 0; i < count; i++){pthread_mutex_lock(&mutex);n = number;n++;number = n;pthread_mutex_unlock(&mutex);}pthread_exit(NULL);
}void *mythread2(void *arg)
{int i = 0, n = 0;for (i = 0; i < count; i++){pthread_mutex_lock(&mutex);n = number;n++;number = n;pthread_mutex_unlock(&mutex);}pthread_exit(NULL);
}int main(int argc, char **argv)
{//互斥锁初始化pthread_mutex_init(&mutex, NULL);// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,// void *(*start_routine) (void *), void *arg);pthread_t thread[2];int ret = pthread_create(&thread[0], NULL, mythread1, NULL);if (ret < 0){printf("pthread1_create error,[%s]\n", strerror(ret));return -1;}ret = pthread_create(&thread[1], NULL, mythread2, NULL);if (ret < 0){printf("pthread2_create error,[%s]\n", strerror(ret));return -1;}//等待进程退出pthread_join(thread[0], NULL);pthread_join(thread[1], NULL);//释放互斥锁pthread_mutex_destroy(&mutex);printf("number == [%d]\n", number);return 0;
}
linux-守护进程和线程相关推荐
- 【Linux系统编程】守护进程、线程
------------->[Linux系统编程/网络编程](学习目录汇总) <-------------- 目录 1.守护进程 1.1 进程组 1.2 会话 1.3 setsid()函数 ...
- .NET跨平台实践：.NetCore、.Net5/6 Linux守护进程设计
几年前,我写过两篇关于用C#开发Linux守护进程的技术文章,分别是<.NET跨平台实践:用C#开发Linux守护进程.NET跨平台实践:再谈用C#开发Linux守护进程 - 完整篇 这就是本文 ...
- .NET跨平台实践：再谈用C#开发Linux守护进程 — 完整篇
Linux守护进程是Linux的后台服务进程,相当于Windows服务,对于为Linux开发服务程序的朋友来说,Linux守护进程相关技术是必不可少的,因为这个技术不仅仅是为了开发守护进程,还可以拓展 ...
- linux下查看进程的线程数,linux查看进程的线程数
top -H -p $PID #查看对应进程的那个线程占用CPU过高 1.top -H 手册中说:-H : Threads toggle 加上这个选项启动top,top一行显示一个线程.否则,它一行 ...
- 笔记整理--Linux守护进程
Linux多进程开发(三)进程创建之守护进程的学习 - _Liang_Happy_Life__Dream - 51CTO技术博客 - Google Chrome (2013/10/11 16:48:2 ...
- linux - 守护进程
守护进程和线程 守护进程 简介 守护进程是Linux中的后台服务进程,通常独立于控制终端周期性的执行某些任务或等待某些发生的事件.Linux后台的一些系统服务进程,没有控制终端,不可以和用户交互. 守 ...
- Linux守护进程实现
Linux守护进程 redis版: void daemonize(void) {int fd;if (fork() != 0) exit(0); /* parent exits */setsid(); ...
- Linux 命令详解（六）Linux 守护进程的启动方法
Linux 守护进程的启动方法 http://www.ruanyifeng.com/blog/2016/02/linux-daemon.html
- .NET跨平台实践：用C#开发Linux守护进程
Linux守护进程(Daemon)是Linux的后台服务进程,它脱离了与控制终端的关联,直接由Linux init进程管理其生命周期,即使你关闭了控制台,daemon也能在后台正常工作. 一句话,为L ...
- 深入理解Linux守护进程
深入理解Linux守护进程Linux服务器在启动时需要启动很多系统服务,它们向本地和网络用户提供了Linux的系统功能接口,直接面向应用程序和用户.提供这些服务的程序是由运行在后台的守护进程(daem ...
最新文章
- pr 文件结构不一致_建筑工程合同与招投标文件不一致，工程结款应该以哪份文件为主？...
- 《c++语言导学》——1.7 常量
- linux lock函数,Linux lock_kernel()函数的分析。
- python ndarray find_python – 从存储在NumPy ndarrays中的图像中查找特定(R,G,B)颜色值的(x,y)索引...
- @postconstruct注解方法没有执行_被标记为事务的方法互相调用的坑（下）
- C#、VB.NET 使用System.Media.SoundPlayer播放音乐
- vmware虚拟机网络模式
- 在ios中运用core animation暂停和继续动画
- matlab符号运算转置出现conj的解决办法
- 关于IDEA的一些常用的快捷键整合，赶紧进来KK......
- 共模和差模信号及其噪音抑制
- python公开直播课_今晚Python与人工智能直播课来袭，Mars喊你快上车
- Mysql联表update数据
- t检验(t test)
- 利用flex布局在父元素和子元素宽高不明的情况下设置某一子元素剩余父元素的宽高
- 第一部份1：JMF基础原理与相关术语介绍 。。。。快速了解JMF有什么相关内容
- 远程链接linux桌面的软件,远程linux桌面软件
- php购物车页面如何做,HTML代码实现简易购物车
- android smallestWidth 限定符屏幕适配方案dimens.xml
- 破解梵蒂冈秘密档案，这个AI认识中世纪手写拉丁文