本文介绍: Linux进程表就像一个数据结构,它把当前加载内存中的所有进程的有关信息保存一个表中,其中包括进程的PID、进程状态命令字符串和其它一些ps命令输出的各类信息进程表的长度是有限制的,所以操作系统能够支持的同时运行进程数也是有限制的,如今可同时运行进程可能只与用于建立进程表项的内存容量有关。在Linux系统中,PR值指的是进程的优先级。Autoconf解决系统特使构建运行信息的难题,但在软件开发时还有更多的难题,GNU构建系统是为了更好开发软件开发一套完整的公益事业。

系列文章目录



十、调试

断言

#include <assert.h>
void assert(int expression);

assert宏对表达式进行求值,如果结果为零,它就往标准错误写一些诊断信息然后调用abort结束程序运行
头文件assert.h定义的宏受到NDEBUG影响。如果程序处理这个头文件时已经定义了NDEBUG,就不定assert宏。

十一、进程和信息

进程定义一个其中运行一个多个线程地址空间和这些线程需要的系统资源。可简单看作运行着的程序。

pid==1一般是init进程。

进程表

Linux进程表就像一个数据结构,它把当前加载在内存中的所有进程的有关信息保存一个表中,其中包括进程的PID、进程的状态命令字符串和其它一些ps命令输出的各类信息操作系统通过进程的PID对它们进行管理,这些PID是进程表的索引。进程表的长度是有限制的,所以操作系统能够支持的同时运行的进程数也是有限制的,如今可同时运行的进程数可能只与用于建立进程表项的内存容量有关。

在这里插入图片描述

进程调度

一个进程的nice默认为0,并将根据这个进程的表现而不断变化。
可以使用nice命令设置进程的nice值,使用renice命令调整它的值。

nice prog_name & #它将分配一个+10的nice
renice 10 pid  # Guess what will happen.

在Linux系统中,PR值指的是进程的优先级。PR值越小,表示进程的优先级越高,而PR值越大,表示进程的优先级越低。这是因为Linux系统中采用静态优先级动态优先级相结合调度算法

静态优先级由nice值来表示范围通常是-20到+19,其中-20是最高优先级,+19是最低优先级。而PR值则是通过将nice值进行转换得到的,具体的计算方式是:

PR = 20 + nice

因此,当nice值越小时,PR值越大,进程的优先级就越高。

动态优先级则是根据进程的行为和运行状态实时调整的,使得系统更具响应性。这样,通过将静态优先级和动态优先级结合起来,Linux系统可以根据进程的行为和系统负载合理分配CPU资源,从而实现更好的性能响应性。

启动新进程

int system(const char* string);
// 运行以字符参数的形式传递给他的命令(并等待命令的完成,依命令而定)。命令的执行情况就如同在shell执行
// system创建子进程,wait与否取决于 输入的命令

execve函数
fork
wait, waitpid

信号

术语生成(raise)表示一个信号的产生,捕获(catch)表示接收到一个信号信号shell终端处理器生成来引起中断

信号处理

信号集

#include <signal.h>
int sigaddset(sigset_t* set, int signo);
int sigemptyset(sigset_t* set);
int sigfillset(sigset_t* set);
int sigdelset(sigset_t* set, int signo);

// signo是否集合中。是:1; 否:0;给定信号无效:-1,并设置errno为EINVAL。
int sigismember(sigset_t* set, int signo);
// 进程的信号屏蔽字的设置检查
/*
	how: -SIG_BLOCK:把set中的信号添加到信号屏蔽字中
		 -SIG_SETMASK:把信号屏蔽设置参数set中的信号
		 -SIG_UNBLOCK:从信号屏蔽字中删除set中的信号
*/
int sigprocmask(int how, const sigset_t* set, sigset_t* oset);

// 将被阻塞的信号中停留在待处理状态一组信号写到参数set指向的信号集中。
int sigpending(sigset_t* set);

// 使得进程挂起自己的执行,直到信号集中的一个信号到达为止
int sigsuspend(const sigset_t* sigmask);
  1. sigaction标志
macro description
SA_NOCLDSTOP 子进程停止时不产生SIGCHLD信号
SA_RESETHAND 将对此信号的处理方式在信号处理函数的入口处重置为SIG_DFL
SA_RESTART 重启中断函数而不是给出EINTR错误
SA_NODEFER 捕获到信号时不讲它添加到信号屏蔽字中
即,在执行信号处理函数时依然可以捕获信号

信号处理函数可以在其执行期间被中断并再次被调用。当返回到第一次调用时,它能否继续正确操作是很关键的。这不仅仅是递归(调用自身)的问题,而是可重入可以安全进入和再次执行)的问题。在信号处理函数可以使用的可重入系统调用:
在这里插入图片描述

发送信号

想要发送一个信号,发送进程 必须拥有相应的权限。这通常意味着两个进程必须拥有相同用户ID

unsigned int alarm(unsigned int seconds);

在这里插入图片描述
子进程给父进程发送SIGALARM信号

#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

static int alarm_fired = 0;

void sigchild(int sig)
{
    printf("sigchildn");
}
void ding(int sig)
{
    alarm_fired = 1;
}
int main()
{
    pid_t pid;
    printf("alarm application startingn");
    pid = fork();
    switch (pid)
    {
    case -1:
        perror("fork");
        exit(EXIT_FAILURE);
        break;
    case 0:
        // sleep(1);
        pid = getppid();
        // kill(pid, SIGCHLD);
        sleep(5);
        kill(pid, SIGALRM);
        exit(EXIT_SUCCESS);
        break;
    }
    printf("waiting for alarm to go offn");
    signal(SIGCHLD, sigchild);
    signal(SIGALRM, ding);
    pause();
    if (alarm_fired)
        printf("Ding!n");
    else 
        printf("not dingn");
    printf("donen");
    exit(0);
}

  闹钟模拟程序通过fork调用启动新的进程。这个子进程休眠5秒后向其父进程发送一个SIGALRM信号。父进程在安排好捕获SIGALRM信号后暂停运行,直到接收到一个信号为止。此程序并未在信号处理函数直接调用printf,而是通过在该函数设置标志,然后main数中检查该标志来完成消息输出
  使用信号并挂起程序的执行是Linux程序设计中的一个重要部分。这意味着程序不需要总是在执行着。程序不必在一个循环中无休止地检查某个事件是否已发生,相反,它可以等待事件的发生。这在只有一个CPU的多用户环境中尤其重要,进程共享着一个处理器,繁忙的等待将会对系统的性能造成极大的影响。程序中信号的使用将带来一个特殊问题“如果信号出现在系统调用的执行过程中会发生什么情况?”答:“视情况而定”。一般来说,你只需要考虑慢系统调用,如从终端数据,如果在这个系统调用等待数据出现一个信号,它就会返回一个错误。如果在程序中使用信号,需要注意一些系统调用会因为接收到了一个信号而失败,而这种错误情况可能是你在添加信号处理函数之前没有考虑到的。
  在编写程序处理信号部分代码时必须非常小心,因为在使用信号的程序中会出现各种各样的“竞态条件”。如,如果想调用pause等待一个信号,可信号却出现在pause之前,就会使程序无限期的等待一个不会发生的事情。这些竞态条件都是一些对时间要求很苛刻的问题。所以在检查和信号相关代码时总是要非常小心。

十二、POSIX线程

c++ thread库

线程创建

#include <pthread.h>
// 创建线程
int pthread_create(pthread_t* thid, pthread_attr_t* attr, void *(*start_routine)(void*), void* arg);
// 终止线程
void pthread_exit(void *retval);
// join or detach
int pthread_join(pthread_t thid, void **thread_retval);
int pthread_detach (pthread_t __th);

线程同步

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);  // 当sem为0时则无法-1而阻塞
int sem_post(sem_t *sem);  // +1无上限
int sem_destroy(sem_t *sem);  // 销毁信号量
#include <pthread.h>
// pthread_mutex_init(&amp;mutex, NULL);
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

线程属性

#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy (pthread_attr_t *__attr);

/*
 * detachstate: PTHREAD_CREATE_JOINABLE/PTHREAD_CREATE_DETACHED
*/
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
/*
 * schedpolicy:控制线程的调度方式。它的取值可以是SCHED_OTHER(默认)SCHED_RPSCHED_FIFO,
 * 其他两种方式只能用于超级用户
*/
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
/*
 * 与schedpolicy结合使用,它可以对SCHED_OTHER策略运行的线程的调度进行控制
*/
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param); 
/*
 * PTHREAD_EXPLICIT_SCHED(default, 调度属性明确设置)/PTHREAD_INHERIT_SCHED(继承创建者的属性)
*/
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit);
int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit);
/*
 * 控制线程调度的计算方式取值:PTHREAD_SCOPE_SYSTEM
*/
int pthread_attr_setscope(pthread_attr_t *attr, int scope);
int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);
/*
 * 控制栈大小
*/
int pthread_attr_setstacksize(pthread_attr_t *attr, int stacksize);
int pthread_attr_getstacksize(const pthread_attr_t *attr, int *stacksize);

通过线程属性设置线程分离

// ignore header
int thread_finished = 0;

void* thread_function(void* arg)
{
    printf("thread_function is running. Argument was %sn", (char*)arg);
    sleep(4);
    printf("Second thread setting finished flag, and exiting nown");
    thread_finished = 1;
    pthread_exit(NULL);   // 这里等价于return NULL;
}

int main()
{
    int res;
    pthread_t a_thread;
    pthread_attr_t thread_attr;
    int max_priority, min_priority;
    struct sched_param scheduling_value;
    // init thread_attr
    res = pthread_attr_init(&amp;thread_attr);
    if (res != 0)
    {
        perror("Attribute creation failed");
        exit(EXIT_FAILURE);
    }
    // 设置线程分离
    res = pthread_attr_setdetachstate(&amp;thread_attr, PTHREAD_CREATE_DETACHED);
    if (res != 0)
    {
        perror("Setting detached attribute failed");
        pthread_attr_destroy(&amp;thread_attr);
        exit(EXIT_FAILURE);
    }
    // 设置调度策略
    res = pthread_attr_setschedpolicy(&amp;thread_attr, SCHED_OTHER);
    if (res != 0)
    {
        perror("Setting scheduling policy failed");
        pthread_attr_destroy(&amp;thread_attr);
        exit(EXIT_FAILURE);
    }
    // 查看优先级策略
    max_priority = sched_get_priority_max(SCHED_OTHER);
    min_priority = sched_get_priority_min(SCHED_OTHER);
    // 设置优先级
    scheduling_value.sched_priority = min_priority;
    res = pthread_attr_setschedparam(&amp;thread_attr, &amp;scheduling_value);
    if (res != 0)
    {
        perror("Setting scheduling priority failed");
        pthread_attr_destroy(&amp;thread_attr);
        exit(EXIT_FAILURE);
    } 
    // 创建线程
    res = pthread_create(&amp;a_thread, &amp;thread_attr, thread_function, (void*)"Hello");
    if (res != 0)
    {
        perror("Thread creation failed");
        pthread_attr_destroy(&amp;thread_attr);
        exit(EXIT_FAILURE);
    }
    // 函数完成后,线程已经被创建,并且线程的属性已经被传递给了新创建的线程。因此,可以安全地销毁线程属性对象
    pthread_attr_destroy(&amp;thread_attr);
    while (!thread_finished)
    {
        printf("Waiting for thread to say it's finished...n");
        sleep(1);
    }
    printf("Other thread finished, bye!n");
    exit(EXIT_SUCCESS);
}

取消一个线程

让一个线程令另一个线程终止。

#include <pthread.h>
// 请求另一个线程终止
int pthread_cancel(pthread_t thread);

// 第一层控制是否接收请求 PTHREAD_CANCEL_ENABLE(默认状态)/PTHREAD_CANCEL_DISABLE
int pthread_setcancelstate(int state, int *oldstate);
// 第二层控制,PTHREAD_CANCEL_ASYNCHRONOUS(立即行动)/PTHREAD_CANCEL_DEFERRED(执行到取消点处,默认状态)
// 取消点:pthread_join, pthread_cond_wait, pthread_cond_timedwait, pthread_testcancel, sem_wait, sigwait
// 某些阻塞函数也可能潜在取消
int pthread_setcanceltype(int type, int *oldtype);

pthread_exit, exit, _exit

  1. exit函数:
  2. _exit函数:
  3. pthread_exit函数:

十三、管道

popen, pipe

通过管道命令行进行交互system只能调用命令而不能与其通讯,popen通过管道与调用的命令进行数传递

#include <stdio.h>
FILE* popen(const char* command, const char* open_mode);
int pclose(FILE* stream_to_close);
#include <unistd.h>
// 1写入,0读取
// 管道内有缓存
int pipe(int file_descriptor[2]);

父子进程

在子进程中运行一个与其父进程完全不同的另外一个程序,而不仅仅运行一个相同程序,通过exec调用完成工作这里的一个难点是,通过exec调用的进程需要知道应该访问哪个文件描述符。如果子进程本身有file_pipes数据的一份副本,所以不成问题。但经过exec调用后,原先的进程被新的替换了。为了解决问题,可以将文件描述符作为一个参数传递给用exec启动的程序。

example

管道的写端被关闭时,read将返回0,而不是阻塞。read无效文件会返回-1。
只有把父子进程中针对管道的写fd关闭管道才会被认为是关闭

注:
  fork复制调用进程,包括文件描述符指向,即父进程的文件描述符指向一个操作系统对象,则子进程的描述符与父进程相同
  在调用exec函数族时,管道(pipe)通常不会被自动关闭。因此在之后的进程中文描述符依然可用。
  在调用exec后文件描述是否可用取决于该文件描述符的状态,若通过fcntl函数将fd设置为了FD_CLOEXEC,则新程序关闭描述符。
  当进程退出后大部分操作系统对象都会被关闭,但有一些资源除外。

将管道用作标准输入标准输出

命名管道:FIFO

# Ubuntu实测权限不会受到umask影响
mkfifo [-m mode] filename
#include <sys/types.h>
#include <sys/stat.h>
// Ubuntu实测权限会受到umask影响
int mkfifo(const char* filename, mode_t mode);
  1. 使用open打开FIFO文件
    open(const char* path, O_RDONLY);
    open(const char* path, O_RDONLY | O_NONBLOCK);
    open(const char* path, O_WRONLY);
    open(const char* path, O_WRONLY | O_NONBLOCK);
    

    如果没有进程以读方式打开管道,非阻塞方式open调用将失败,但非阻塞读open总是成功

十四、IPC通讯

信号量

semaphore.hsys/sem.h 都是在C语言中用于处理信号量头文件,但它们在功能上有一些区别

  1. semaphore.h

  2. sys/sem.h

总的来说,如果你的目标编写跨平台代码,最好使用 semaphore.h。如果你在Linux平台编写代码需要更底层的控制,可能选择使用 sys/sem.h。然而,考虑sys/sem.h 是Linux特定的,使用它可能使你的代码在其他Unix-like系统上不可移植

操作 说明
P(sv) 如果sv的值大于零,就给它减去1;如果它的值等于零,就挂起该进程的执行
V(sv) 如果有其它进程因等待sv而被挂起,就它恢复运行;如果没有进程等待sv,就给他加1
#include <sys/sem.h>
// 
int semctl(int sem_id, int sem_num, int command, ...);
// 创建一个新信号量或取的一个已有信号量
int setmget(key_t key, int num_sems, int semflags);
// 
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

共享内存

#include <sys/shm.h>
// 将共享内存连接到进程地址空间
void* shmat(int shm_id, const void* shm_addr, int shmflg);
// 控制共享内存
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
// 将共享内存从当前地址空间分离
int shmdt(const void* shm_addr);
// 返回shm_id, 传入key,大小和权限
int shmget(key_t key, size_t size, int shmflg);

消息队列

在这里插入图片描述

#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

// 创建消息队列
int msgget(key_t key, int msgflg);

// 接收消息
int msgrcv(int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg);
	- msgtype: 如果只想按照消息发送的顺序接收则将其设为0,如果只想获取某一特定类型的消息就将其设为相应类型,如果想接收类型等于或小于n的消息,就将其设为-n
	- msgflg: 用于设置当队列中没有相应类型的消息可以接收时将发生的事情

// 把消息添加进消息队列
int msgsnd(int msqid, const void *msg_ptr, size_t msg_sz, int msgflg);
	- msg_ptr: 最好定义成以下形式 struct my_message{long int message_type; /*data*/};
	- msg_sz: data部分的长度
	- msgflg: 控制在当前消息队列满或超限时的行为

IPC状态命令

ipcs

十八、Linux标准

LSB标准

LSB系统初始化

Linux系统运行级别

运行级别 description
0 停止。用作一种可以在系统关闭时切换到的逻辑状态
1 单用户模式。非目录的其他目录可能不会在这种模式下被装载,网络功能也将被禁用。该模式通常用于系统维护
2 多用户模式,但未启用网络功能
3 正常的带网络功能的多用户模式,使用文本模式的登录界面
4 保留
5 正常的带网络功能的多用户模式,使用图形登录界面
6 用于重启系统的伪运行级别

与运行级别相伴的一组用于启动、关闭和重启服务初始化脚本位置/etc/init.d/
用于控制初始化脚本行为的控制参数

参数 description
start 启动(或重启服务
stop 停止服务
restart 重启服务 ,它一般是通过先停止服务再重启服务的方式实现
reload 重置服务,在不停止服务的情况下重新装载所有的参数
forcereload 如果服务支持这个选项,就重载服务,否则,就重启服务
status 文本方式打印服务的状态信息,并返回一个可以用来确定服务状态的状态码

文件系统层次结构标准

Filesystem Hierarchy Standard
https://www.pathname.com/fhs/

目录 是否需要 用户
/bin Y 重要的系统二进制文件
/boot Y 动系统所需要的文件
/dev Y 设备文件
/etc Y 系统配置文件
/lib Y 标准函数库
/media Y 用于装载可移动媒体位置
/mnt Y 方便临时装载如CD-ROM和内存棒等设备的目录
/opt Y 其他应用程序软件
/sbin Y 在系统启动时需要的重要的系统二进制文件
/srv Y 用于系统提供的服务的只读数据
/tmp Y 临时文件
/usr Y
/var Y 可变数据,如日志文件

GNU 构建系统
Autoconf解决了系统特使构建和运行时信息的难题,但在软件开发时还有更多的难题,GNU构建系统是为了更好的开发软件开发的一套完整的公益事业。
主要组成部分有Autoconf、Automake和Libtool


原文地址:https://blog.csdn.net/surfaceyan/article/details/134354550

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_37934.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注