Linux守护者进程以及线程————全网最详细！！！！！

已于 2024-01-24 12:01:37 修改
阅读量1.4k 收藏 20
点赞数 26
分类专栏： linux高并发服务器 文章标签： linux 网络 运维
于 2024-01-24 12:00:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45030264/article/details/135818351
版权

守护进程

守护进程介绍

守护进程（Daemon Process），也就是通常说的 Daemon 进程（精灵进程），是 Linux 中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。

守护进程是个特殊的孤儿进程，这种进程脱离终端，为什么要脱离终端呢？之所以脱离于终端是为了避免进程被任何终端所产生的信息所打断，其在执行过程中的信息也不在任何终端上显示。由于在 Linux 中，每一个系统与用户进行交流的界面称为终端，每一个从此终端开始运行的进程都会依附于这个终端，这个终端就称为这些进程的控制终端，当控制终端被关闭时，相应的进程都会自动关闭。

Linux 的大多数服务器就是用守护进程实现的。比如，Internet 服务器 inetd，Web 服务器 httpd 等。

守护进程模型

1) 创建子进程，父进程退出(必须)

所有工作在子进程中进行形式上脱离了控制终端

2) 在子进程中创建新会话(必须)

setsid()函数
使子进程完全独立出来，脱离控制

3) 改变当前目录为根目录(不是必须)

chdir()函数
防止占用可卸载的文件系统
也可以换成其它路径

4) 重设文件权限掩码(不是必须)

umask()函数
防止继承的文件创建屏蔽字拒绝某些权限
增加守护进程灵活性

5) 关闭文件描述符(不是必须)

继承的打开文件不会用到，浪费系统资源，无法卸载

6) 开始执行守护进程核心工作(必须)

守护进程退出处理程序模型

守护进程参考代码

写一个守护进程, 每隔2s获取一次系统时间, 将这个时间写入到磁盘文件：

/*
* time_t rawtime;
* time ( &rawtime  ); --- 获取时间，以秒计，从1970年1月一日起算，存于rawtime
* localtime ( &rawtime  ); //转为当地时间，tm 时间结构
* asctime() // 转为标准ASCII时间格式：
*/
void write_time(int num)
{
    time_t rawtime;
    struct tm * timeinfo;
    // 获取时间
    time(&rawtime);
#if 0
    // 转为本地时间
    timeinfo = localtime(&rawtime);
    // 转为标准ASCII时间格式
    char *cur = asctime(timeinfo);
#else
    char* cur = ctime(&rawtime);
#endif
​
    // 将得到的时间写入文件中
    int fd = open("/home/edu/timelog.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
    if (fd == -1)
    {
        perror("open error");
        exit(1);
    }
    // 写文件
    int ret = write(fd, cur, strlen(cur) + 1);
    if (ret == -1)
    {
        perror("write error");
        exit(1);
    }
    // 关闭文件
    close(fd);
}
​
int main(int argc, const char* argv[])
{
    pid_t pid = fork();
    if (pid == -1)
    {
        perror("fork error");
        exit(1);
    }
​
    if (pid > 0)
    {
        // 父进程退出
        exit(1);
    }
    else if (pid == 0)
    {
        // 子进程
        // 提升为会长，同时也是新进程组的组长
        setsid();
​
        // 更改进程的执行目录
        chdir("/home/edu");
​
        // 更改掩码
        umask(0022);
​
        // 关闭文件描述符
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);
​
        // 注册信号捕捉函数
        //先注册，再定时
        struct sigaction sigact;
        sigact.sa_flags = 0;
        sigemptyset(&sigact.sa_mask);
        sigact.sa_handler = write_time;
        sigaction(SIGALRM, &sigact, NULL);
​
        // 设置定时器
        struct itimerval act;
        // 定时周期
        act.it_interval.tv_sec = 2;
        act.it_interval.tv_usec = 0;
        // 设置第一次触发定时器时间
        act.it_value.tv_sec = 2;
        act.it_value.tv_usec = 0;
        // 开始计时
        setitimer(ITIMER_REAL, &act, NULL);
​
        // 防止子进程退出
        while (1);
    }
​
    return 0;
}

线程简介

线程概念

在许多经典的操作系统教科书中，总是把进程定义为程序的执行实例，它并不执行什么, 只是维护应用程序所需的各种资源，而线程则是真正的执行实体。

所以，线程是轻量级的进程（LWP：light weight process），在Linux环境下线程的本质仍是进程。

为了让进程完成一定的工作，进程必须至少包含一个线程。在这里插入图片描述

进程，直观点说，保存在硬盘上的程序运行以后，会在内存空间里形成一个独立的内存体，这个内存体有自己的地址空间，有自己的堆，上级挂靠单位是操作系统。操作系统会以进程为单位，分配系统资源，所以我们也说，进程是CPU分配资源的最小单位。

线程存在与进程当中(进程可以认为是线程的容器)，是操作系统调度执行的最小单位。说通俗点，线程就是干活的。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

线程是进程的一个实体，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

如果说进程是一个资源管家，负责从主人那里要资源的话，那么线程就是干活的苦力。一个管家必须完成一项工作，就需要最少一个苦力，也就是说，一个进程最少包含一个线程，也可以包含多个线程。苦力要干活，就需要依托于管家，所以说一个线程，必须属于某一个进程。

进程有自己的地址空间，线程使用进程的地址空间，也就是说，进程里的资源，线程都是有权访问的，比如说堆啊，栈啊，静态存储区什么的。

进程是操作系统分配资源的最小单位

线程是操作系统调度的最小单位

线程函数列表安装

sudo apt-get install manpages-posix-dev

【说明】manpages-posix-dev 包含 POSIX 的 header files 和 library calls 的用法

man -k pthread  用于查看相关介绍

NPTL

当 Linux 最初开发时，在内核中并不能真正支持线程。但是它的确可以通过 clone() 系统调用将进程作为可调度的实体。这个调用创建了调用进程（calling process）的一个拷贝，这个拷贝与调用进程共享相同的地址空间。LinuxThreads 项目使用这个调用来完全在用户空间模拟对线程的支持。不幸的是，这种方法有一些缺点，尤其是在信号处理、调度和进程间同步原语方面都存在问题。另外，这个线程模型也不符合 POSIX 的要求。

要改进 LinuxThreads，非常明显我们需要内核的支持，并且需要重写线程库。有两个相互竞争的项目开始来满足这些要求。一个包括 IBM 的开发人员的团队开展了 NGPT（Next-Generation POSIX Threads）项目。同时，Red Hat 的一些开发人员开展了 NPTL 项目。NGPT 在 2003 年中期被放弃了，把这个领域完全留给了 NPTL。

NPTL，或称为 Native POSIX Thread Library，是 Linux 线程的一个新实现，它克服了 LinuxThreads 的缺点，同时也符合 POSIX 的需求。与 LinuxThreads 相比，它在性能和稳定性方面都提供了重大的改进。

查看当前pthread库版本：getconf GNU_LIBPTHREAD_VERSION
在这里插入图片描述

线程的特点

类Unix系统中，早期是没有“线程”概念的，80年代才引入，借助进程机制实现出了线程的概念。

因此在这类系统中，进程和线程关系密切：

  1. 线程是轻量级进程(light-weight process)，也有PCB，创建线程使用的底层函数和进程一样，都是clone

  2. 从内核里看进程和线程是一样的，都有各自不同的PCB.

  3. 进程可以蜕变成线程

  4. 在linux下，线程最是小的执行单位；进程是最小的分配资源单位

在这里插入图片描述
查看指定进程的LWP号：

ps -Lf pid

实际上，无论是创建进程的fork，还是创建线程的pthread_create，底层实现都是调用同一个内核函数 clone 。

  • 如果复制对方的地址空间，那么就产出一个“进程”；

  • 如果共享对方的地址空间，就产生一个“线程”。

Linux内核是不区分进程和线程的, 只在用户层面上进行区分。所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。

线程共享资源

  1. 文件描述符表

  2. 每种信号的处理方式

  3. 当前工作目录

  4. 用户ID和组ID

内存地址空间 (.text/.data/.bss/heap/共享库)

线程的优缺点

优点：

  • 提高程序并发性

  • 开销小

  • 数据通信、共享数据方便

缺点：

  • 库函数，不稳定

  • 调试、编写困难、gdb不支持

  • 对信号支持不好

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

线程常用操作

线程号

就像每个进程都有一个进程号一样，每个线程也有一个线程号。进程号在整个系统中是唯一的，但线程号不同，线程号只在它所属的进程环境中有效。

进程号用 pid_t 数据类型表示，是一个非负整数。线程号则用 pthread_t 数据类型来表示，Linux 使用无符号长整数表示。

有的系统在实现pthread_t 的时候，用一个结构体来表示，所以在可移植的操作系统实现不能把它做为整数处理。

pthread_self函数：

#include <pthread.h>
​
pthread_t pthread_self(void);
功能：
    获取线程号。
参数：
    无
返回值：
    调用线程的线程 ID 。

pthread_equal函数:

int pthread_equal(pthread_t t1, pthread_t t2);
功能：
    判断线程号 t1 和 t2 是否相等。为了方便移植，尽量使用函数来比较线程 ID。
参数：
    t1，t2：待判断的线程号。
返回值：
    相等：  非 0
    不相等：0

参考程序：

int main()
{
    pthread_t thread_id;
​
    thread_id = pthread_self(); // 返回调用线程的线程ID
    printf("Thread ID = %lu \n", thread_id);
​
    if (0 != pthread_equal(thread_id, pthread_self()))
    {
        printf("Equal!\n");
    }
    else
    {
        printf("Not equal!\n");
    }
​
    return 0;
}

【注意】线程函数的程序在 pthread 库中，故链接时要加上参数 -lpthread。

线程的创建

pthread_create函数：

#include <pthread.h>
​
int pthread_create(pthread_t *thread,
            const pthread_attr_t *attr,
            void *(*start_routine)(void *),
            void *arg );
功能：
    创建一个线程。
参数：
    thread：线程标识符地址。
    attr：线程属性结构体地址，通常设置为 NULL。
    start_routine：线程函数的入口地址。
    arg：传给线程函数的参数。
返回值：
    成功：0
    失败：非 0

在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。

由于pthread_create的错误码不保存在errno中，因此不能直接用perror()打印错误信息，可以先用strerror()把错误码转换成错误信息再打印。

参考程序：

// 回调函数
void *thread_fun(void * arg)
{
    sleep(1);
    int num = *((int *)arg);
    printf("int the new thread: num = %d\n", num);
​
    return NULL;
}
​
int main()
{
    pthread_t tid;
    int test = 100;
​
    // 返回错误号
    int ret = pthread_create(&tid, NULL, thread_fun, (void *)&test);
    if (ret != 0)
    {
        printf("error number: %d\n", ret);
        // 根据错误号打印错误信息
        printf("error information: %s\n", strerror(ret));
    }
​
    while (1);
​
    return 0;
}

线程资源回收

pthread_join函数：

#include <pthread.h>
​
int pthread_join(pthread_t thread, void **retval);
功能：
    等待线程结束（此函数会阻塞），并回收线程资源，类似进程的 wait() 函数。如果线程已经结束，那么该函数会立即返回。
参数：
    thread：被等待的线程号。
    retval：用来存储线程退出状态的指针的地址。
返回值：
    成功：0
    失败：非 0

参考程序：

void *thead(void *arg)
{
    static int num = 123; //静态变量
​
    printf("after 2 seceonds, thread will return\n");
    sleep(2);
​
    return &num;
}
​
int main()
{
    pthread_t tid;
    int ret = 0;
    void *value = NULL;
​
    // 创建线程
    pthread_create(&tid, NULL, thead, NULL);
​
​
    // 等待线程号为 tid 的线程，如果此线程结束就回收其资源
    // &value保存线程退出的返回值
    pthread_join(tid, &value);
​
    printf("value = %d\n", *((int *)value));
​
    return 0;
}

调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：

  1. 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。

  2. 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。

  3. 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。

线程分离

一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。

不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

pthread_detach函数：

#include <pthread.h>
​
int pthread_detach(pthread_t thread);
功能：
    使调用线程与当前进程分离，分离后不代表此线程不依赖与当前进程，线程分离的目的是将线程资源的回收工作交由系统自动来完成，也就是说当被分离的线程结束之后，系统会自动回收它的资源。所以，此函数不会阻塞。
参数：
    thread：线程号。
返回值：
    成功：0
    失败：非0

线程退出

在进程中我们可以调用exit函数或_exit函数来结束进程，在一个线程中我们可以通过以下三种在不终止整个进程的情况下停止它的控制流。

  • 线程从执行函数中返回。
  • 线程调用pthread_exit退出线程。
  • 线程可以被同一进程中的其它线程取消。
pthread_exit函数：

#include <pthread.h>
​
void pthread_exit(void *retval);
功能：
    退出调用线程。一个进程中的多个线程是共享该进程的数据段，因此，通常线程退出后所占用的资源并不会释放。
参数：
    retval：存储线程退出状态的指针。
返回值：无  
​

参考程序:

void *thread(void *arg)
{
    static int num = 123; //静态变量
    int i = 0;
    while (1)
    {
        printf("I am runing\n");
        sleep(1);
        i++;
        if (i == 3)
        {
            pthread_exit((void *)&num);
            // return &num;
        }
    }
​
    return NULL;
}
​
int main(int argc, char *argv[])
{
    int ret = 0;
    pthread_t tid;
    void *value = NULL;
​
    pthread_create(&tid, NULL, thread, NULL);
​
​
    pthread_join(tid, &value);
    printf("value = %d\n", *(int *)value);
​
    return 0;
}
​

线程取消

#include <pthread.h>
​
int pthread_cancel(pthread_t thread);
功能：
    杀死(取消)线程
参数：
    thread : 目标线程ID。
返回值：
    成功：0
    失败：出错编号

注意：线程的取消并不是实时的，而又一定的延时。需要等待线程到达某个取消点(检查点)。

类似于玩游戏存档，必须到达指定的场所(存档点，如：客栈、仓库、城里等)才能存储进度。

杀死线程也不是立刻就能完成，必须要到达取消点。

取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write… 执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。

可粗略认为一个系统调用(进入内核)即为一个取消点。

参考程序:

void *thread_cancel(void *arg)
{
    while (1)
    {
        pthread_testcancel(); //设置取消点
    }
    return NULL;
}
​
int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, thread_cancel, NULL); //创建线程
​
    sleep(3);                   //3秒后
    pthread_cancel(tid); //取消tid线程
​
    pthread_join(tid, NULL);
​
    return 0;
}
​

线程属性

概述

Linux下线程的属性是可以根据实际项目需要，进行设置，之前我们讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问题。

如我们对程序的性能提出更高的要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的使用，增加最大线程个数。

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. 线程栈最低地址

属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释放资源。

线程属性主要包括如下属性：作用域（scope）、栈尺寸（stack size）、栈地址（stack address）、优先级（priority）、分离的状态（detached state）、调度策略和参数（scheduling policy and parameters）。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。

线程属性初始化和销毁

#include <pthread.h>
​
int pthread_attr_init(pthread_attr_t *attr);
功能：
    初始化线程属性函数，注意：应先初始化线程属性，再pthread_create创建线程
参数：
    attr：线程属性结构体
返回值：
    成功：0
    失败：错误号
​
int pthread_attr_destroy(pthread_attr_t *attr);
功能：
    销毁线程属性所占用的资源函数
参数：
    attr：线程属性结构体
返回值：
    成功：0
    失败：错误号

线程分离状态

线程的分离状态决定一个线程以什么样的方式来终止自己。

  • 非分离状态：线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
  • 分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。
相关函数：

#include <pthread.h>
​
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
功能：设置线程分离状态
参数：
    attr：已初始化的线程属性
    detachstate：    分离状态
        PTHREAD_CREATE_DETACHED（分离线程）
        PTHREAD_CREATE_JOINABLE（非分离线程）
返回值：
    成功：0
    失败：非0
​
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
功能：获取线程分离状态
参数：
    attr：已初始化的线程属性
    detachstate：    分离状态
        PTHREAD_CREATE_DETACHED（分离线程）
        PTHREAD _CREATE_JOINABLE（非分离线程）
返回值：
    成功：0
    失败：非0
​

这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。

要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。

设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

线程栈地址

POSIX.1定义了两个常量来检测系统是否支持栈属性：

  • _POSIX_THREAD_ATTR_STACKADDR

  • _POSIX_THREAD_ATTR_STACKSIZE
    也可以给sysconf函数传递来进行检测：

  • _SC_THREAD_ATTR_STACKADDR

  • _SC_THREAD_ATTR_STACKSIZE
    当进程栈地址空间不够用时，指定新建线程使用由malloc分配的空间作为自己的栈空间。通过pthread_attr_setstack和pthread_attr_getstack两个函数分别设置和获取线程的栈地址。

#include <pthread.h>
​
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr,  size_t stacksize);
功能：设置线程的栈地址
参数：
    attr：指向一个线程属性的指针
    stackaddr：内存首地址
    stacksize：返回线程的堆栈大小
返回值：
    成功：0
    失败：错误号
​
int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr,  size_t *stacksize);
功能：获取线程的栈地址
参数：
    attr：指向一个线程属性的指针
    stackaddr：返回获取的栈地址
    stacksize：返回获取的栈大小
返回值：
    成功：0
    失败：错误号

线程栈大小

当系统中有很多线程时，可能需要减小每个线程栈的默认大小，防止进程的地址空间不够用,当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线程栈的默认大小。


#include <pthread.h>
​
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
功能：设置线程的栈大小
参数：
    attr：指向一个线程属性的指针
    stacksize：线程的堆栈大小
返回值：
    成功：0
    失败：错误号
​
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
功能：获取线程的栈大小
参数： 
    attr：指向一个线程属性的指针
    stacksize：返回线程的堆栈大小
返回值：
    成功：0
    失败：错误号

综合参考程序


#define SIZE 0x100000
​
void *th_fun(void *arg)
{
    while (1)
    {
        sleep(1);
    }
}
​
int main()
{
    pthread_t tid;
    int err, detachstate, i = 1;
​
    pthread_attr_t attr;
    size_t stacksize;
    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 unknown\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. 主线程退出其他线程不退出，主线程应调用pthread_exit

  2. 避免僵尸线程

  • pthread_join

  • pthread_detach

  • pthread_create指定分离属性

被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;

  1. malloc和mmap申请的内存可以被其他线程释放

  2. 应避免在多线程模型中调用fork，除非马上exec，子进程中只有调用fork的线程存在，其他线程t在子进程中均pthread_exit

  3. 信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制

白小白的学习笔记
关注
  • 26
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linux 守护线程
jiletianzun的博客
03-10 421
作用：每隔两秒，把时间转成字符串写入文件 例子： #include <iostream> #include<signal.h> #include<time.h> #include<string.h> #include<unistd.h> #include<stdlib.h> #include<sys/types.h> #include <sys/time.h> #include <sys/stat.
Linux系统编程---守护进程、线程
qq_51647149的博客
04-18 1317
守护进程的创建、线程共享及线程的相关函数实现
【Linux系统编程】守护进程、线程
qq_59084325的博客
09-05 578
【Linux系统编程】守护进程、线程（超详细）
Linux管理员必备——Linux系统服务（daemon）与systemctl管理服务（上）
最新发布
博客虽小，世界尽在其中
06-03 1855
本文深入探讨了Linux系统服务（daemon）及其与systemctl管理工具的紧密关系。首先，文章简要介绍了Linux系统服务（daemon）的概念，强调它们在操作系统后台持续运行以支持各种系统功能和服务的重要性。接着，文章详细阐述了systemctl作为Systemd初始化系统和系统管理服务器的核心命令工具的作用，包括如何启动、停止、重启、重载和检查系统服务状态等。 随后，文章通过实际案例展示了如何使用systemctl来管理服务，包括设置服务的开机自启、查看服务日志以及进行服务的依赖关系管理等。文
linux守护进程
z961968549的博客
05-30 305
概述 操作系统总有一些默默在后台运行着的程序，被称作服务，不与使用者进行交互。他们的功能很简单一般是重复性周期性的或者只有等待某些事件的发生才会做出相应动作，例如邮件接收监听程序每隔一段时间就会扫描一下是否有新的邮件到来，linux中同样存在这样的程序，在后台运行脱离终端控制，不在终端进行交互，这样的进程被称作守护进程，这样的进程不受用户注销影响 通俗解释 （这是一个粗...
linux-守护进程和线程
qq_43605009的博客
07-23 929
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 pt
Linux守护进程
长期更新自学笔记
01-04 1842
守护进程： 后台执行，运行周期长，无需和用户交互
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
FIFO.rar_Help!
09-23
在某些文件系统中，可以创建特殊的文件类型——FIFO文件，也称为命名管道。这种文件不是存储数据的常规文件，而是提供两个进程之间通信的通道。一个进程可以写入FIFO，而另一个进程在同一时间可以读取，同样遵循FIFO...
Java_snake.zip_Snake!_java 博客
09-23
在本项目中，我们关注的是一个基于Java编程语言实现的经典游戏——贪吃蛇。这个名为"Snake!_java 博客"的项目是作者参考他人的博客创作的，旨在为学习Java编程的人提供一个有价值的实践案例。让我们深入探讨这个项目...
Java-happy-farm.zip_Happy!
09-23
《Java开心农场——五子棋游戏详解》 在IT领域，尤其是编程世界中，小游戏的开发经常被用作学习和实践编程技术的平台。今天我们要深入探讨的是一个基于Java语言开发的小游戏——“五子棋”。这个名为"Java-happy-...
Linux进程控制——线程创建pthread_create()
01-06
Linux进程控制——线程创建 实现代码 #include #include #include void* func(void *arg) { printf(Child thread!\n); printf(Thread ID is %ld\n, (unsigned long) pthread_self()); return 0; } int main(int ...
linux的守护进程
weixin_43743847的博客
05-20 533
linux的守护进程本质是为服务器的后台做日志的 什么是日志呢 就是保留信息的 用数据库 比如学生的姓名 年龄等等 还有时间 许多数据库的table 并且不断的及时更新 由客户端的输入信息 守护进程其实本质就是个孤儿进程 因为他在后台运行 我们在使用这个后台进程的时候 需要注意一个问题 因为父进程是进程组组长 所以不能进行创建新的会话组 sid ，所以只能是通过子进程进行创建守护进程 在后台...
【Linux】守护线程(Daemon)
zion--6135的博客
05-31 944
1.会话 会话组 2.线程 线程组 现有的机制是：某个运行在终端里面的程序，如果关闭终端，就会杀死 setdsid():关闭终端后，这个线程也不会被关闭。
9.4 文件IO基本操作
weixin_30633949的博客
09-10 81
fopen后必须判断 FILE *p 是否返回NULLfopen打开文件后，一定要fclosefeof 判断文件是否到达最后对一个文件进行简单的加密解密操作#include <stdio.h>#include <stdlib.h>#include <string.h>#define S_KEY 10void code(const char * src , c...
Linux 守护进程
雪碧柠七的博客
05-14 504
认识守护进程    守护进程也成为精灵进程，是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待某些发生地事件。守护进程是一种很有用的进程。Linux的大多数服务器就是用守护进程所实现的。     Linux系统启动时会启动很多系统服务进程。这些服务进程没有控制终端，不能直接和用户交互。其他进程都是在用户登陆或运行程序时创建，在运行结束或用户注销时终止，但系统服务进程（守护进...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白小白的学习笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值