Linux系统编程（守护进程和线程）

最新推荐文章于 2024-05-22 07:30:00 发布
最新推荐文章于 2024-05-22 07:30:00 发布
阅读量231 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43873349/article/details/107667136
版权

文章目录

守护进程的特点

  1. 一个linux后台服务进程
  2. 不依赖于控制终端
  3. 周期性执行某些任务
  4. 不受用户登录和注销的影响
  5. 一般以d结尾

进程组和会话

  进程组: 一个进程包含多个进程
  会话: 多个组组成一个会话.

  • 创建会话的进程不能是组长进程;
  • 一般创建会话是父进程先fork子进程, 然后父进程退出, 让子进程调用setsid函数
  • 创建一个会话, 这个子进程既是会长也是组长;
  • 只要是创建了会话, 这个进程就脱离了控制终端的影响.

创建守护进程模型:

  1. 父进程fork子进程, 然后父进程退出.
    目的是: 子进程肯定不是组长进程, 为后续调用setsid函数提供了条件.
  2. 子进程调用setsid函数创建一个新的会话.
    1. 该子进程成了该会话的会长
    2. 该子进程成了该组的组长进程.
    3. 不再受控制终端的影响了
  3. 改变当前的工作目录, chdir -----不是必须的
  4. 重设文件掩码, umask(0000) -----不是必须的
  5. 关闭STDIN_FILENO STDOUT_FILENO STDERR_FILENO —不是必须的
  6. 核心操作

编写一个守护进程，每隔2S钟获取一次系统时间，并将这个时间写入磁盘文件。

  分析：

  • 每隔2S钟: 使用setitimer函数设置时钟, 该时钟发送的是SIGALRM信号,
  • 信号操作: 注册信号处理函数,signal或者sigaction, 还有一个信号处理函数
  • 获取一次系统时间: time函数的使用, ctime函数的使用
  • 写入磁盘文件: 文件操作函数 —> open write close

mydaemon.c

//创建守护进程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>

void myfunc(int signo)
{
	//打开文件
	int fd = open("mydemon.log", O_RDWR | O_CREAT | O_APPEND, 0755);
	if(fd<0)
	{
		return;
	}

	//获取当前的系统时间
	time_t t;
	time(&t);
	char *p = ctime(&t);
	
	//将时间写入文件
	write(fd, p, strlen(p));

	close(fd);

	return;
}

int main()
{
	//父进程fork子进程, 然后父进程退出
	pid_t pid = fork();
	if(pid<0 || pid>0)
	{
		exit(1);
	}
	
	//子进程调用setsid函数创建会话
	setsid();

	//改变当前的工作目录
	chdir("/home/itcast/log");

	//改变文件掩码
	umask(0000);

	//关闭标准输入,输出和错误输出文件描述符
	close(STDIN_FILENO);
	close(STDOUT_FILENO);
	close(STDERR_FILENO);

	//核心操作
	//注册信号处理函数
	struct sigaction act;
	act.sa_handler = myfunc;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);	
	sigaction(SIGALRM, &act, NULL);

	//设置时钟
	struct itimerval tm;
	tm.it_interval.tv_sec = 2;
	tm.it_interval.tv_usec = 0;
	tm.it_value.tv_sec = 3;
	tm.it_value.tv_usec = 0;
	setitimer(ITIMER_REAL, &tm, NULL);

	printf("hello world\n");

	while(1)
	{
		sleep(1);
	}
}

优化:

  1. 不再频繁的打开和关闭文件
  2. 如何控制log文件大小 test.log
//编写守护进程: 每隔2秒获取一次系统时间,并将时间写入文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>

int fd;
int flag = 0;

//信号处理函数
void sighandler(int signo)
{
	//获取当前系统时间
	time_t tm;
	time(&tm);
	char *p = ctime(&tm);

	if(flag==0)
	{
		//新建文件
		fd = open("./mydaemon.log", O_RDWR | O_CREAT | O_APPEND, 0777);
		if(fd<0)
		{
			perror("open error");
			return;
		}
		flag = 1;
	}

	//写文件
	write(fd, p, strlen(p));

	return;
}
int main()
{
	//fork子进程，父进程退出
	pid_t pid = fork();
	if(pid<0 || pid>0)
	{
		exit(0);
	}

	//子进程调用setsid函数创建新会话
	setsid();

	//改变当前工作目录chdir
	chdir("/home/itcast");

	//重设文件掩码
	umask(0000);

	//关闭标准输入,标准输出, 标准错误输出这三个文件描述符
	close(STDIN_FILENO);
	close(STDOUT_FILENO);
	close(STDERR_FILENO);

	//核心工作
	struct sigaction act;
	act.sa_handler = sighandler;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);
	sigaction(SIGALRM, &act, NULL);

	//调用setitimer函数设置时钟
	struct itimerval tm;
	tm.it_interval.tv_sec = 2;
	tm.it_interval.tv_usec = 0;
	tm.it_value.tv_sec = 3;
	tm.it_value.tv_usec = 0;
	setitimer(ITIMER_REAL, &tm, NULL);

	while(1)
	{
		//获取文件大小
		int size = lseek(fd, 0, SEEK_END);
		if(size>100)
		{
			close(fd);
			rename("./mydaemon.log", "./mydaemon.log.bak");
			flag =0;
		}
	}

	close(fd);
	
	return 0;
}

线程相关函数

在这里插入图片描述

  1. 创建子线程: pthread_create
    pthread_create.c
//创建子线程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
}

int main()
{
	//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, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//目的是为了让子线程能够执行起来
	sleep(1);
	return 0;
}

pthread_create1.c

//创建子线程: 传递参数
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

struct Test
{
	int data;
	char name[64];
};

//线程执行函数
void *mythread(void *arg)
{
	//int n = *(int *)arg;
	struct Test *p = (struct Test *)arg;
	//struct Test *p = arg;
	//printf("n==[%d]\n", n);
	printf("[%d][%s]\n", p->data, p->name);
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
}

int main()
{
	int n = 99;
	struct Test t;
	memset(&t, 0x00, sizeof(struct Test));
	t.data = 88;
	strcpy(t.name, "xiaowen");	
	//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, &n);
	int ret = pthread_create(&thread, NULL, mythread, &t);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//目的是为了让子线程能够执行起来
	sleep(1);
	return 0;
}

在这里插入图片描述pthread_create_loop.c

//循环创建子线程,并且打印是第几个子线程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	int i = *(int *)arg;
	printf("[%d]:child thread, pid==[%d], id==[%ld]\n", i, getpid(), pthread_self());
	sleep(100);
}

int main()
{
	//int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
	//                      void *(*start_routine) (void *), void *arg);
	//创建子线程
	int ret;
	int i = 0;
	int n = 5;
	int arr[5];
	pthread_t thread[5];
	for(i=0; i<n; i++)
	{
		arr[i] = i;
		ret = pthread_create(&thread[i], NULL, mythread, &arr[i]);
		if(ret!=0)
		{
			printf("pthread_create error, [%s]\n", strerror(ret));
			return -1;
		}
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//目的是为了让子线程能够执行起来
	sleep(100);
	return 0;
}
  1. 线程退出: pthread_exit
  2. 回收子线程: pthread_join
//线程退出函数测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

struct Test
{
	int data;
	char name[64];
};
int g_var = 9;
struct Test t;

//线程执行函数
void *mythread(void *arg)
{
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
	//printf("[%p]\n", &g_var);
	//pthread_exit(&g_var);
	memset(&t, 0x00, sizeof(t));
	t.data = 99;
	strcpy(t.name, "xiaowen");
	pthread_exit(&t);
}

int main()
{
	//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, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//回收子线程
	void *p = NULL;
	pthread_join(thread, &p);	
	//int n = *(int *)p;
	struct Test *pt = (struct Test *)p;
	printf("child exit status:[%d],[%s],[%p]\n",  pt->data, pt->name, p);

	return 0;
}
  1. 设置子线程为分离属性: pthread_detach
//设置子线程为分离属性
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
	sleep(10);
}

int main()
{
	//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, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//设置线程为分离属性
	pthread_detach(thread);

	//子线程设置分离属性,则pthread_join不再阻塞,立刻返回
	ret = pthread_join(thread, NULL);
	if(ret!=0)
	{
		printf("pthread_join error:[%s]\n", strerror(ret));
	}

	//目的是为了让子线程能够执行起来
	sleep(1);
	return 0;
}
  1. 杀死（取消）线程: pthread_cancel
//创建子线程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	while(1)
	{
		int a;
		int b;

		//设置取消点
		//pthread_testcancel();

		printf("-----\n");
		
	}
}

int main()
{
	//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, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//取消子线程
	pthread_cancel(thread);

	pthread_join(thread, NULL);
	return 0;
}
  1. 比较两个线程ID是否相等: pthread_equal
//比较线程ID是否相等
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
}

int main()
{
	//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, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//比较线程ID
	//if(pthread_equal(thread, pthread_self())!=0)
	if(pthread_equal(pthread_self(), pthread_self())!=0)
	{
		printf("two thread id is same\n");
	}
	else
	{
		printf("two thread id is not same\n");
	}

	//目的是为了让子线程能够执行起来
	sleep(1);
	return 0;
}

在创建线程的时候设置线程属性为分离属性:
1 pthread_attr_t attr;
2 pthread_attr_init(&attr);
3 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
4 pthread_create(&thread, &attr, mythread, NULL);
5 pthread_attr_destroy(&attr);

pthread_attr.c

//在创建子线程的时候设置分离属性
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//线程执行函数
void *mythread(void *arg)
{
	printf("child thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());
	sleep(2);
}

int main()
{
	//定义pthread_attr_t类型的变量
	pthread_attr_t attr;
	
	//初始化attr变量
	pthread_attr_init(&attr);

	//设置attr为分离属性
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

	//创建子线程
	pthread_t thread;
	int ret = pthread_create(&thread, &attr, mythread, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}
	printf("main thread, pid==[%d], id==[%ld]\n", getpid(), pthread_self());

	//释放线程属性
	pthread_attr_destroy(&attr);

	//验证子线程是否为分离属性
	ret = pthread_join(thread, NULL);
	if(ret!=0)
	{
		printf("pthread_join error:[%s]\n", strerror(ret));
	}

	return 0;
}
Mr.魏（魏先生）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux守护进程
09-13
linux守护进程实例，教学使用，学习Linux操作系统必看。
Linux系统下的多线程编程入门.pdf
12-20
这种设计允许程序在处理多个任务时更加灵活，提高资源利用率和系统响应速度。在Linux系统中，线程共享同一地址空间，这意味着它们可以快速地访问相同的数据，但也可能导致数据竞争问题。 二、创建与管理线程 在...
【Linux系统编程】进程和线程的区别
C/C++软件工程师、嵌入式软件工程师、物联网研发工程师、C/C++讲师、物联网讲师、嵌入式讲师---欢迎大家一起交流(私信添加博主微信)
11-06 1154
00. 目录 文章目录00. 目录01. 进程和线程区别02. 附录 01. 进程和线程区别 在许多经典的操作系统教科书中，总是把进程定义为程序的执行实例，它并不执行什么, 只是维护应用程序所需的各种资源，而线程则是真正的执行实体。 为了让进程完成一定的工作，进程中必须至少包含一个线程。 进程，直观点说，保存在硬盘上的程序运行以后，会在内存空间里形成一个独立的内存体，这个内存体有自己的地址空间，...
Linux进阶篇——守护进程、进程树与进程资源限制详解
最新发布
博客虽小，世界尽在其中
05-22 1905
本文深入探讨了Linux系统中守护进程、进程树以及进程资源限制的概念和应用。首先，文章介绍了守护进程（Daemon）在Linux系统中的作用和重要性，详细解释了守护进程是如何在后台持续运行以提供系统服务或管理任务的。通过实例和说明，读者可以清晰地理解守护进程的特点和启动方式。 接着，文章进一步探讨了进程树（Process Tree）的概念。进程树是Linux系统中所有进程及其子进程之间关系的直观表示。通过阐述进程ID（PID）、父进程ID（PPID）以及进程之间的层级关系，文章展示了如何使用工具（如ps、
Linux系统编程一（程序、进程和线程）
qq_43598865的博客
06-01 171
ln hello.c hello2.c //通过ln来创建hello.c的硬链接文件hello2.c 只有文件才可以创建硬链接，删除其中一个硬链接文件时，别的文件还是可以查看，当修改互为硬链接的文件时，所有文件同时更新 ln -s //创建软链接 目录可以创建软链接 ...
Linux系统编程——09-linux-day08(守护进程-线程)
Alliswell_WP
07-03 279
在学习Linux系统课程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 09-linux-day08(守护进程-线程) 一、学习目标 1、守护进程的特点 2、熟练进行守护进程的创建 3、熟练掌握多线程的创建 4、熟练掌握线程的退出和资源回收 二、守护进程+线程 1、守护进程相关的概念 会话：进程组的更高一级，多个进程组对应一个会...
Linux系统编程之线程
刘猿猿
12-05 175
线程的概念 回顾进程 在介绍线程之前，我们先来回顾下进程，进程的定义就是指一个具有独立功能的程序在某个数据集上的一次动态执行的过程，是系统进程资源分配和调度的基本单元。 一次任务的运行可以并发激活多个进程，这些进程相互合作完成该任务的一个最终目标。 操作系统对进程的描述：PCB（进程控制块）Linux下的进程描述——task_struct。 那么线程是什么呢？ 线程是进程中的一条执行流，Li...
06--Linux系统编程-守护进程、线程.pdf
10-08
linux开发
【嵌入式软件工程师面经】Linux系统编程（线程进程）.pdf
04-27
### 嵌入式软件工程师面经：Linux系统编程（线程进程） #### 一、线程与进程的区别 1. **定义**： - **进程**：是系统中的一个可执行程序的一次运行实例，它是系统进行资源分配和调度的基本单位。 - **线程**：...
C语言编写Linux守护进程实例
09-03
守护进程在Linux系统中扮演着重要的角色，它们通常在后台运行，执行特定的服务或任务，例如网络服务器、定时任务管理等。C语言是编写Linux守护进程的常用工具，因为其简洁且接近底层的特性。 首先，理解守护进程的...
线程
瑞_板凳精神
11-10 86
线程 进程可以蜕变成线程 线程可以看做寄存器和栈的集合 进程是分配资源最小的单位，而线程是调度的最小单位，线程共用进程资源 线程有时候被称为轻量级进程（light weight process LWP） 线程共享资源 1.文件描述符表 2.每种信号的处理方式 3.当前工作目录 4.用户ID和组ID 5.内存地址空间（.text/.data/.bss/heap/共享库） 线程非共享资源 1.线程id 2.处理器现场和栈指针（内核栈） 3.独立的栈空间（用户空间栈） 4.errno变量
Linux守护进程
yulindianzi的博客
08-20 109
一般采用以d结尾的名字。进程组中的成员是可以转移的，如果当前进程组中的成员被转移到了其他的组，或者进制中的所有进程都退出了，那么这个进程组也就不存在了。重定向文件描述符(和关闭二选一): 改变文件描述符关联的默认文件, 让他们指向一个特殊的文件/dev/null，只要把数据扔到这个特殊的设备文件中, 数据被被销毁了。如果pgid对应的进程组不存在，会创建一个新的进程组, 因此要求 pid == pgid, 当前进程就是组长了。这个进程会变成当前会话中的第一个进程，同时也会变成新的进程组的组长。
Linux守护进程与多线程详解：创建、管理和通信
本文主要介绍了守护进程和多线程的概念、创建与管理，涉及C语言编程及Linux系统知识。作者参考了B站上的视频，并欢迎读者指正。 守护进程（daemon）是运行在后台的特殊进程，它们通常不与任何终端关联，常用于提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值