Linux多进程(三) 信号信号集与统一事件源

信号是由用户、系统或者进程发送给目标进程的信息，以通知目标进程某个状态的改变或系统异常。Linux信号可由如下条件产生：

  • 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入Ctrl+C通常会给进程发送一个中断信号。
  • 系统异常。比如浮点异常和非法内存段访问。
  • 系统状态变化。比如alarm定时器到期将引起SIGALRM信号。
  • 运行kill命令或调用kill函数。

服务器程序必须处理一些常见信号，以免异常终止。

一、信号概述

1.1、发送信号

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

pid：目标进程

  • pid>0：信号发送给PID=pid的进程
  • pid=0：信号发送给本进程组内的其他进程
  • pid=-1：信号发送给除了init进程外的所有进程，但发送者需要有对目标进程发送信号的权限
  • pid<-1：发送给组ID为-pid的进程组中的所有成员

sig：准备向目标进程发送的信号，sig大于0，如果sig为0则kill函数不发送任何信号

该函数成功时返回0，失败则返回-1并设置errno

  • EINVAL 无效信号
  • EPERM 该进程没有权限发送信号给任何一个目标进程
  • ESRCH 目标进程，进程组不存在

1.2、信号的处理方式

信号处理函数的原型如下：信号处理函数只带有一个整型参数，该参数用来指示信号类型。信号处理函数应该是可重入的，否则很容易引发一些竞态条件。所以信号处理函数中严禁调用不安全函数。

#include <signal.h>

typedef void(*__sighandler_t)(int);

除了用户自定义信号处理函数外，bits/signum.h头文件中还定义了信号的两种其他处理方式：

#include <bits/signum.h>

#define SIG_DFL((__sighandler_t)0)
#define SIG_IGN((__sighandler_t)1)

SIG_IGN表示忽略目标信号，SIG_DFL表示使用信号的默认处理方式。信号的默认处理方式有如下几种：

  • 结束进程（Term）
  • 忽略信号（Ign）
  • 结束进程并生成核心转储文件（Core）
  • 暂停进程（Stop）
  • 以及继续进程（Cont）。

1.3、Linux信号

Linux的可用信号都定义在bits/signum.h头文件中，其中包括标准信号和POSIX实时信号。下面列出一些常见的信号

信号起源默认行为含义
SIGHUPPOSIX终止终端挂断或控制进程终止
SIGINTPOSIX终止键盘中断字符，通常是Ctrl+C
SIGQUITPOSIX终止+核心转储键盘退出字符，通常是Ctrl+\
SIGILLPOSIX终止+核心转储非法指令
SIGABRTANSI终止+核心转储中止信号，由abort函数生成
SIGFPEPOSIX终止+核心转储浮点异常
SIGKILLPOSIX终止不可捕获，强制终止进程
SIGSEGVPOSIX终止+核心转储无效的内存引用
SIGPIPEPOSIX终止管道破裂
SIGALRMPOSIX终止定时器信号
SIGTERMPOSIX终止终止请求，通常用于优雅地终止进程
SIGUSR1POSIX终止用户定义信号1
SIGUSR2POSIX终止用户定义信号2
SIGCHLDPOSIX忽略子进程状态改变
SIGCONTBSD继续执行继续一个停止的进程
SIGSTOPPOSIX停止不可捕获，停止进程
SIGTSTPPOSIX停止键盘挂起字符，通常是Ctrl+Z
SIGTTINPOSIX停止后台进程请求输入
SIGTTOUPOSIX停止后台进程请求输出
SIGBUSUNIX终止+核心转储总线错误
SIGPOLLSystem V终止I/O可用性变化
SIGPROFBSD终止Profiling定时器到期
SIGSYSUNIX终止+核心转储非法系统调用
SIGTRAPBSD终止+核心转储跟踪/断点陷阱
SIGURGBSD忽略Socket紧急情况
SIGVTALRMBSD终止虚拟定时器到期
SIGXCPUBSD终止+核心转储超出CPU时间限制
SIGXFSZBSD终止+核心转储文件大小超出限制

1.4、中断系统调用

如果程序在执行处于阻塞状态的系统调用时接收到信号，并且我们为该信号设置了信号处理函数，则默认情况下系统调用将被中断，并且errno被设置为EINTR。我们可以使用sigaction函数（见后文）为信号设置SA_RESTART标志以自动重启被该信号中断的系统调用。

对于默认行为是暂停进程的信号（比如SIGSTOP、SIGTTIN），如果我们没有为它们设置信号处理函数，则它们也可以中断某些系统调用（比如connect、epoll_wait）。POSIX没有规定这种行为，这是Linux独有的。

二、信号函数

2.1、发送信号

2.1.1、kill函数

给某一个进程发送一个信号

#include <signal.h>
int kill(pid_t pid, int sig);
  • pid: 进程ID（man 文档里边写的比较详细）
  • sig: 要发送的信号

举个例子

// 自己杀死自己
kill(getpid(), 9);
// 子进程杀死自己的父进程，可以看到发送的是10号信号，父进程也不必立即处理这个信号
kill(getppid(), 10);
2.1.2、raise

给当前进程发送指定的信号，函数原型如下：

#include <signal.h>
int raise(int sig);
2.1.3、abort

给当前进程发送一个固定信号 (SIGABRT)，杀死当前进程，函数原型如下：

#include <stdlib.h>
void abort(void);

2.2、为信号设置处理函数

2.2.1、signal

要为一个信号设置处理函数，可以使用下面的signal系统调用：

#include <signal.h>

_sighandler_t signal(int sig, _sighandler _t_handler)

sig参数指出要捕获的信号类型。

_handler参数是_sighandler_t类型的函数指针，用于指定信号sig的处理函数。

signal函数成功时返回一个函数指针，该函数指针的类型也是_sighandler_t。这个返回值是前一次调用signal函数时传入的函数指针，或者是信号sig对应的默认处理函数指针SIG_DEF（如果是第一次调用signal的话）。

2.2.2、sigaction

更健壮的接口是下面的系统调用

#include <signal.h>

int sigaction(int sig, const struct sigaction* act, struct sigaction* oact);

sig参数指出要捕获的信号类型，act参数指定新的信号处理方式，oact参数则输出信号先前的处理方式。

struct sigaction {
#ifdef __USE_POSIX199309

    union {
        _sighandler_t sa_handler;
        void(*sa_sigaction)(int, siginfo_t*, void*);
    } _sigaction_handler;

#define sa_handler    __sigaction_handler.sa_handler
#define sa_sigaction  __sigaction_handler.sa_sigaction

#else
	_sighandler_t sa_handler;
#endif
    _sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
};

sa_hander成员指定信号处理函数。

sa_mask成员增加进程的信号掩码，以指定哪些信号不能发送给本进程。sa_mask是信号集sigset_t（_sigset_t的同义词）类型，该类型指定一组信号。

sa_flags成员用于设置程序收到信号时的行为，其可选值如下（或下面的组合）：

  • SA_RESETHAND：当调用信号处理程序时，将信号的处理程序重置为默认值。这意味着处理程序在每次调用后都会被重新设置，不会保持永久性。
  • SA_NODEFER：在调用信号处理程序时，不会阻塞当前信号。通常，当信号处理程序运行时，相同类型的信号会被阻塞，直到处理程序执行完成。使用 SA_NODEFER 标志可以避免此阻塞。
  • SA_RESTART：当系统调用由于信号中断而返回时，自动重新启动该系统调用，而不是返回 -1 并将 errno 设置为 EINTR。这使得系统调用在接收到信号时可以自动恢复执行，而不会中断。
  • SA_SIGINFO：指定使用带有三个参数的信号处理函数，而不是传统的只有一个参数的信号处理函数。带有三个参数的处理函数接收有关信号的更多信息，如信号来源、信号的附加数据等。
  • SA_NOCLDSTOP：子进程停止或继续运行时，不会向父进程发送 SIGCHLD 信号。通常，当子进程停止或继续时，会向父进程发送 SIGCHLD 信号，但使用 SA_NOCLDSTOP 标志可以防止这种行为。
  • SA_NOCLDWAIT：当子进程退出时，不会创建僵尸进程，并且不会向父进程发送 SIGCHLD 信号。通常，父进程需要调用 wait 或 waitpid 来等待子进程退出并获取其退出状态，但使用 SA_NOCLDWAIT 标志可以避免这种行为。

2.3、定时器

2.3.1、alarm

alarm函数只能进行单次定时，定时完成发射出一个信号。

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
  • seconds：倒计时秒数。 倒计时完成发送一个信号 SIGALRM , 当前进程会收到这个信号，这个信号默认的处理动作是中断当前进程
  • 返回值大于0表示倒计时还剩多少秒，返回值为0表示倒计时完成, 信号被发出
2.3.2、setitimer

setitimer函数可以进行周期性定时，每触发一次定时器就会发射出一个信号。

#include <sys/time.h>

struct itimerval {
	struct timeval it_interval; /* 时间间隔 */
	struct timeval it_value;    /* 第一次触发定时器的时长 */
};

// 这个结构体表示的是一个时间段: tv_sec + tv_usec
struct timeval {
	time_t      tv_sec;         /* 秒 */
	suseconds_t tv_usec;        /* 微妙 */
};

int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
  • which: 定时器使用什么样的计时法则, 不同的计时法则发出的信号不同
    • ITIMER_REAL: 自然计时法, 最常用, 发出的信号为SIGALRM, 一般使用这个宏值，自然计时法时间 = 用户区 + 内核 + 消耗的时间(从进程的用户区到内核区切换使用的总时间)
    • ITIMER_VIRTUAL: 只计算程序在用户区运行使用的时间，发射的信号为 SIGVTALRM
    • ITIMER_PROF: 只计算内核运行使用的时间, 发出的信号为SIGPROF
  • new_value: 给定时器设置的定时信息, 传入参数
  • old_value: 上一次给定时器设置的定时信息, 传出参数，如果不需要这个信息, 指定为NULL

2.4、示例

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

// 定时器信号的处理动作
void doing(int arg) {
    printf("当前捕捉到的信号是: %d\n", arg);
}

int main() {
    // 注册要捕捉哪一个信号, 执行什么样的处理动作
    signal(SIGALRM, doing);
    // 调用定时器函数设置定时器函数
    struct itimerval newact;
    // 3s之后发出第一个定时器信号, 之后每隔1s发出一个定时器信号
    newact.it_value.tv_sec = 3;
    newact.it_value.tv_usec = 0;
    newact.it_interval.tv_sec = 1;
    newact.it_interval.tv_usec = 0;
    setitimer(ITIMER_REAL, &newact, NULL);
    while(1);

    return 0;
}

image-20240423172035813

三、信号集

3.1、信号集函数

Linux使用数据结构sigset_t来表示一组信号

#include <bits/sigset.h>
#define _SIGSET_NWORDS (1024/(8*sizeof(unsigned long int)))

typedef struct {
	unsigned long int __val[_SIGSET_NWORDS];
}__sigset_t;

sigset_t实际上是一个长整型数组，数组的每个元素的每个位表示一个信号。在我看来像是一个位图。

Linux提供了如下一组函数来设置、修改、删除和查询信号集：

#include <signal.h>

// 将set集合中所有的标志位设置为0
int sigemptyset(sigset_t *set);
// 将set集合中所有的标志位设置为1
int sigfillset(sigset_t *set);
// 将set集合中某一个信号(signum)对应的标志位设置为1
int sigaddset(sigset_t *set, int signum);
// 将set集合中某一个信号(signum)对应的标志位设置为0
int sigdelset(sigset_t *set, int signum);
// 判断某个信号在集合中对应的标志位到底是0还是1, 如果是0返回0, 如果是1返回1
int sigismember(const sigset_t *set, int signum);

3.2、进程信号掩码

前文提到，可以用sigaction结构体的sa_mask成员来设置进程的信号掩码。此外，如下函数也可以用于设置或查看进程的信号掩码：

#include <signal.h>

int sigprocmask(int_how, _const sigset_t* _set, sigset_t* _oset);

_set参数指定新的信号掩码，_oset参数则输出原来的信号掩码（如果不为NULL的话）

如果_set参数不为NULL，则_how参数指定设置进程信号掩码的方式：

  • SIG_BLOCK 新的进程信号掩码是当前值和 _set 指定信号集的并集
  • SIG_UNBLOCK 新的进程信号掩码是其当前值和 ~_set 信号集的并集，因此 _set 指定的信号集将不被屏蔽
  • SIG_SETMASK 直接将进程信号掩码设置为 _set

如果_set为NULL，则进程信号掩码不变

3.3、被挂起的信号

设置进程信号掩码后，被屏蔽的信号将不能被进程接收。如果给进程发送一个被屏蔽的信号，则操作系统将该信号设置为进程的一个被挂起的信号。如果我们取消对被挂起信号的屏蔽，则它能立即被进程接收到。

如下函数可以获得进程当前被挂起的信号集：

#include <signal.h>

int sigpending(sigset_t* set);

set参数用于保存被挂起的信号集。也就是未决信号集。

进程即使多次接收到同一个被挂起的信号，sigpending函数也只能反映一次。并且，当我们再次使用sigprocmask使能该挂起的信号时，该信号的处理函数也只被触发一次。

sigpending成功时返回0，失败时返回-1并设置errno。

3.4、使用信号集

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

int main()
{
    // 初始化信号集
    sigset_t myset;
    sigemptyset(&myset);
    // 设置阻塞的信号，也就是屏蔽2，3，9号信号
    sigaddset(&myset, SIGINT);  // 2
    sigaddset(&myset, SIGQUIT); // 3
    sigaddset(&myset, SIGKILL); // 9

    // 将初始化的信号集中的数据设置给内核
    sigset_t old;
    sigprocmask(SIG_BLOCK, &myset, &old);

    // 让进程一直运行, 在当前进程中产生对应的信号
    int i = 0;
    while(1) {
        // 读内核的未决信号集
        sigset_t curset;
        sigpending(&curset);
        // 遍历这个信号集
        for(int i=1; i<32; ++i) {
            int ret = sigismember(&curset, i);
            printf("%d", ret);
        }
        printf("\n");
        sleep(1);
        // i++;
        // if(i==10) {
            // 解除阻塞, 重新设置阻塞信号集
            // sigprocmask(SIG_UNBLOCK, &myset, NULL);
            // sigprocmask(SIG_SETMASK, &old, NULL);
        // }
    }
    return 0;
}

可以看下图，当我们按下 ctrl+c 可以发现出现了未决信号SIGINT，当我们按下 ctrl+\ 可以发现出现了未决信号SIGQUIT，

image-iauhfjakshdkfj

四、统一事件源

信号是一种异步事件：信号处理函数和程序的主循环是两条不同的执行路线。很显然，信号处理函数需要尽可能快地执行完毕，以确保该信号不被屏蔽（前面提到过，为了避免一些竞态条件，信号在处理期间，系统不会再次触发它）太久。

一种典型的解决方案是：把信号的主要处理逻辑放到程序的主循环中，当信号处理函数被触发时，它只是简单地通知主循环程序接收到信号，并把信号值传递给主循环，主循环再根据接收到的信号值执行目标信号对应的逻辑代码。信号处理函数通常使用管道来将信号“传递”给主循环：信号处理函数往管道的写端写入信号值，主循环则从管道的读端读出该信号值。那么主循环怎么知道管道上何时有数据可读呢?这很简单，我们只需要使用I/O复用系统调用来监听管道的读端文件描述符上的可读事件。如此一来，信号事件就能和其他I/O事件一样被处理，即统一事件源。

下面给出统一事件源的一个简单实现：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <stdbool.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024
#define MAX_CONNECTIONS 1024
#define PORT 8080
static int pipefd[2];

int setnonblocking(int fd)
{
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

/*信号处理函数*/
void sig_handler(int sig)
{
    /*保留原来的errno，在函数最后恢复，以保证函数的可重入性*/
    int save_errno = errno;
    int msg = sig;
    send(pipefd[1], (char *)&msg, 1, 0); /*将信号值写入管道，以通知主循环*/
    errno = save_errno;
}

/*设置信号的处理函数*/
void addsig(int sig)
{
    struct sigaction sa;
    memset(&sa, '\0', sizeof(struct sigaction));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

int main(int argc, char *argv[])
{
    // 创建 socket 文件描述符
    int listenfd;
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
    {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    // 绑定到指定端口
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = htons(PORT);
    address.sin_addr.s_addr = inet_addr("192.168.189.129");
    int addrlen = sizeof(address);
    if (bind(listenfd, (struct sockaddr *)&address, addrlen) < 0)
    {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    // 开始监听
    if (listen(listenfd, MAX_CONNECTIONS) < 0)
    {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    // 注册epoll事件
    struct epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(1);
    addfd(epollfd, listenfd);
    // 使用socketpair创建管道，注册pipefd[0]上的可读事件
    int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0]);

    // 设置一些信号的处理函数
    addsig(SIGHUP);
    addsig(SIGCHLD);
    addsig(SIGTERM);
    addsig(SIGINT);
    bool stop_server = false;

    while (!stop_server)
    {
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if ((number < 0) && (errno != EINTR))
        {
            printf("epoll failure\n");
            break;
        }
        for (int i = 0; i < number; i++)
        {
            int sockfd = events[i].data.fd;
            /*如果就绪的文件描述符是listenfd，则处理新的连接*/
            if (sockfd == listenfd)
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr *)&client_address, &client_addrlength);
                addfd(epollfd, connfd);
            }
            /*如果就绪的文件描述符是pipefd[0]，则处理信号*/
            else if ((sockfd == pipefd[0]) && (events[i].events & EPOLLIN))
            {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if (ret == -1)
                {
                    continue;
                }
                else if (ret == 0)
                {
                    continue;
                }
                else
                {
                    /*因为每个信号值占1字节，所以按字节来逐个接收信号。我们以SIGTERM为例，来说明如何安全地终止服务器主循环*/
                    for (int i = 0; i < ret; ++i)
                    {
                        switch (signals[i])
                        {
                        case SIGCHLD:
                        case SIGHUP:
                            continue;
                        case SIGTERM:
                        case SIGINT:
                            stop_server = true;
                        }
                    }
                }
            }
        }
    }
    printf("close fds\n");
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    return 0;
}

五、网络编程常用信号

5.1、SIGHUP

当挂起进程的控制终端时，SIGHUP信号将被触发。对于没有控制终端的网络后台程序而言，它们通常利用SIGHUP信号来强制服务器重读配置文件。

5.2、SIGPIPE

默认情况下，往一个读端关闭的管道或socket连接中写数据将引发SIGPIPE信号。我们需要在代码中捕获并处理该信号，或者至少忽略它，因为程序接收到SIGPIPE信号的默认行为是结束进程，而我们绝对不希望因为错误的写操作而导致程序退出。引起SIGPIPE信号的写操作将设置errno为EPIPE。

可以使用send函数的MSG_NOSIGNAL标志来禁止写操作触发SIGPIPE信号。在这种情况下，我们应该使用send函数反馈的errno值来判断管道或者socket连接的读端是否已经关闭。

此外，我们也可以利用I/O复用系统调用来检测管道和socket连接的读端是否已经关闭。以poll为例，当管道的读端关闭时，写端文件描述符上的POLLHUP事件将被触发；当socket连接被对方关闭时，socket上的POLLRDHUP事件将被触发。

5.3、SIGURG

内核通知应用程序带外数据到达主要有两种方法：

一种是I/O复用技术，select等系统调用在接收到带外数据时将返回，并向应用程序报告socket上的异常事件

一种是使用SIGURG信号

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>

#define BUF_SIZE 1024

static int connfd;

void sig_urg( int sig )
{
    int save_errno = errno;
    
    char buffer[ BUF_SIZE ];
    memset( buffer, '\0', BUF_SIZE );
    int ret = recv( connfd, buffer, BUF_SIZE-1, MSG_OOB );
    printf( "got %d bytes of oob data '%s'\n", ret, buffer );

    errno = save_errno;
}

void addsig( int sig, void ( *sig_handler )( int ) )
{
    struct sigaction sa;
    memset( &sa, '\0', sizeof( sa ) );
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset( &sa.sa_mask );
    assert( sigaction( sig, &sa, NULL ) != -1 );
}

int main( int argc, char* argv[] )
{
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi( argv[2] );

    struct sockaddr_in address;
    bzero( &address, sizeof( address ) );
    address.sin_family = AF_INET;
    inet_pton( AF_INET, ip, &address.sin_addr );
    address.sin_port = htons( port );

    int sock = socket( PF_INET, SOCK_STREAM, 0 );
    assert( sock >= 0 );

    int ret = bind( sock, ( struct sockaddr* )&address, sizeof( address ) );
    assert( ret != -1 );

    ret = listen( sock, 5 );
    assert( ret != -1 );

    struct sockaddr_in client;
    socklen_t client_addrlength = sizeof( client );
    connfd = accept( sock, ( struct sockaddr* )&client, &client_addrlength );
    if ( connfd < 0 )
    {
        printf( "errno is: %d\n", errno );
    }
    else
    {
        addsig( SIGURG, sig_urg );
        fcntl( connfd, F_SETOWN, getpid() );

        char buffer[ BUF_SIZE ];
        while( 1 )
        {
            memset( buffer, '\0', BUF_SIZE );
            ret = recv( connfd, buffer, BUF_SIZE-1, 0 );
            if( ret <= 0 )
            {
                break;
            }
            printf( "got %d bytes of normal data '%s'\n", ret, buffer );
        }

        close( connfd );
    }

    close( sock );
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/573757.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

LeetCode:51. N 皇后

LeetCode:51. N 皇后

leetCode51.N皇后 题解分析 代码 class Solution { public:int n;vector<vector<string>> ans;vector<string> path;vector<bool> col, dg,udg;vector<vector<string>> solveNQueens(int _n) {n _n;col vector<bool> (n);dg …
阅读更多...
如何在阿里云快速配置自动定时重启ECS云服务器?

如何在阿里云快速配置自动定时重启ECS云服务器?

背景 无论是电子商务、在线教育、游戏&#xff0c;还是流媒体等业务&#xff0c;服务器的稳定运行都是至关重要的。然而&#xff0c;在实际运行中&#xff0c;我们可能会遇到这样一些场景&#xff1a; 系统更新&#xff1a;一些操作系统或者软件的更新可能需要重启服务器才能…
阅读更多...
政企版 WPS Pro 专业版注册安装教程

政企版 WPS Pro 专业版注册安装教程

政企版 WPS Pro 专业版安装及激活步骤 第 1 步&#xff1a;下载压缩包&#xff08;内含注册码&#xff09;【无解压密码】。 第 2 步&#xff1a;解压缩后&#xff0c;运行 exe 文件&#xff0c;默认步骤安装即可。 第 3 步&#xff1a;安装完成后&#xff0c;新建一个 Word …
阅读更多...
【Camera Sensor Driver笔记】五、点亮指南之Actuator配置

【Camera Sensor Driver笔记】五、点亮指南之Actuator配置

<slaveInfo> actuatorName dw9714v dirver IC 型号 slaveAddress 0x18 i2c write address i2cFrequencyMode FAST i2c 操作频率(400KHz) actuatorType VCM/BIVCM 马达类型 BIVCM&#xff08;中置马达&#xff…
阅读更多...
Andorid进程间通信之 UNIX SOCKET

Andorid进程间通信之 UNIX SOCKET

1&#xff0c;什么是UNIX SOCKET UNIX SOCKET&#xff0c;域套接字&#xff0c;UNIX SOCKET可用于同一台设备进程间通信&#xff0c;它不需要经过网络协议栈&#xff0c;不需要打包拆包、计算校验和、维护序列号应答等&#xff0c;只需要将数据从一个进程复制到另一个进程&…
阅读更多...
WPS-EXCEL:快速删除多个线条对象

WPS-EXCEL:快速删除多个线条对象

问题图 我需要将线条快速删除 方法一:使用定位对象功能 使用定位功能&#xff1a;按Ctrl G打开定位对话框。在对话框中&#xff0c;点击“定位条件”。 定位对象&#xff1a;在定位条件对话框中&#xff0c;勾选“对象”选项&#xff0c;然后点击“确定”。这样&#xff0c;…
阅读更多...
git忽略文件配置 !

git忽略文件配置 !

.gitignore中!表示取反 注意&#xff0c;如果父目录被排除&#xff0c;则父目录下的子目录也会被排除&#xff0c;此时对父目录下的子目录取反也不会生效&#xff0c;比如存在目录结构&#xff0c;再.gitignore目录下配置的 /*&#xff08;排除所有文件&#xff09;&#xff0c…
阅读更多...
探索 Python 的动态类型系统：变量引用、不可变性及高效内存管理与垃圾回收机制的深入分析

探索 Python 的动态类型系统：变量引用、不可变性及高效内存管理与垃圾回收机制的深入分析

文章目录 1. 动态类型及其内存管理解析1.1 变量与对象的引用关系1.2 对象的不可变性和内存地址的变化 2. 垃圾回收与内存优化策略2.1 动态内存分配的基础2.2 Python 的垃圾回收 Python作为一种流行的高级编程语言&#xff0c;以其代码的易读性和简洁性著称。尤其是它的动态类型…
阅读更多...
U盘无法正常格式化？教你一个强力的办法

U盘无法正常格式化？教你一个强力的办法

前言 电脑格式化U盘或者移动硬盘的操作&#xff0c;相信各位小伙伴都是有一定经历的。 如果设备正常&#xff0c;那么进入到【此电脑】&#xff0c;在对应的分区点击【鼠标右键】-【格式化】就可以把对应的存储设备恢复到初始状态。 但凡事都会有例外&#xff0c;比如在格式化…
阅读更多...
SKF 与KISSSOFT的连接

SKF 与KISSSOFT的连接

SKF 与KISSSOFT的连接 HEDZER TILLEMA&#xff0c;荷兰SKF B.V.产品线经理 最近&#xff08;2019年&#xff09;&#xff0c;瑞典滚动轴承制造商斯凯孚&#xff08;SKF&#xff09;和瑞士齿轮箱设计软件开发商KISSsoft已将斯凯孚的轴承计算服务整合到KISSsoft的软件中。借助 K…
阅读更多...
分布式技术在文本摘要生成中的应用

分布式技术在文本摘要生成中的应用

摘要 自然语言处理首先要应对的是如何表示文本以供机器处理&#xff0c;随着网络技术的发展和信息的公开&#xff0c;因特网上可供访问的数字文档成爆炸式的增长&#xff0c;文本摘要生成逐渐成为了自然语言处理领域的重要研究课题。本文主要介绍了分布式技术在文本摘要生成中…
阅读更多...
软件工程中的耦合和内聚

软件工程中的耦合和内聚

耦合 在软件工程中&#xff0c;耦合是一个重要的概念&#xff0c;用于描述模块或组件之间的相互依赖程度。 从非直接耦合到内容耦合的耦合性依次升高&#xff0c;所以非直接耦合是我们最想见到的结果&#xff0c;内容耦合是我们最不想见到的结果。 非直接耦合数据耦合标记耦…
阅读更多...
开源数据集分享———猫脸码客

开源数据集分享———猫脸码客

猫脸码客作为一个专注于开源数据集分享的公众号&#xff0c;致力于为广大用户提供丰富、优质的数据资源。我们精心筛选和整理各类开源数据集&#xff0c;涵盖机器学习、深度学习、自然语言处理等多个领域&#xff0c;以满足不同用户的需求。 (https://img-blog.csdnimg.cn/d98…
阅读更多...
【Python数据库】Redis

【Python数据库】Redis

文章目录 [toc]数据插入数据查询数据更新数据删除查询存在的所有key 个人主页&#xff1a;丷从心 系列专栏&#xff1a;Python数据库 学习指南&#xff1a;Python学习指南 数据插入 from redis import Redisdef insert_data():redis_cli Redis(hostlocalhost, port6379, db…
阅读更多...
【Java--数据结构】链表经典OJ题详解（上）

【Java--数据结构】链表经典OJ题详解（上）

欢迎关注个人主页&#xff1a;逸狼 创造不易&#xff0c;可以点点赞吗~ 如有错误&#xff0c;欢迎指出~ 目录 谈谈头插、头删、尾插、头插的时间复杂度 反转一个单链表 链表的中间结点 返回倒数第k个结点 合并两个链表 谈谈头插、头删、尾插、头插的时间复杂度 头插和头删的时…
阅读更多...
MySQL尾部空格处理与哪些设置有关? 字符集PAD SPACE与NO PAD属性的区别、MySQL字段尾部有空格为什么也能查询出来？

MySQL尾部空格处理与哪些设置有关? 字符集PAD SPACE与NO PAD属性的区别、MySQL字段尾部有空格为什么也能查询出来？

文章目录 一、问题背景二、字符集PAD_ATTRIBUTE属性&#xff08;补齐属性&#xff09;2.2、PAD SPACE与NO PAD的具体意义 三、CHAR类型尾部空格的处理四、其他问题4.1、在PAD SPACE属性时如何实现精准查询 五、总结 以下内容基于MySQL8.0进行讲解 一、问题背景 一次查询中发现…
阅读更多...
CTF之变量1

CTF之变量1

拿到题目发现是一个php代码&#xff0c;意思是用get方式获取args参数。 至于下面那个正则表达式怎么绕过暂且不知&#xff0c;但是题目最上面告诉我们lag In the variable ! &#xff08;意思是flag就在变量中&#xff09;。 那我们就传入全局变量globals&#xff08;&#xf…
阅读更多...
2024深圳杯（东北三省）数学建模C题完整论文讲解（含完整python代码及所有残骸音爆位置求解结果）

2024深圳杯（东北三省）数学建模C题完整论文讲解（含完整python代码及所有残骸音爆位置求解结果）

大家好呀&#xff0c;从发布赛题一直到现在&#xff0c;总算完成了2024深圳杯&#xff08;东北三省数学建模联赛&#xff09;A题多个火箭残骸的准确定位完整的成品论文。 本论文可以保证原创&#xff0c;保证高质量。绝不是随便引用一大堆模型和代码复制粘贴进来完全没有应用糊…
阅读更多...
Java苍穹外卖01-开发环境搭建（Git、nginx）-Swagger-员工管理

Java苍穹外卖01-开发环境搭建（Git、nginx）-Swagger-员工管理

一、开发环境搭建 1.项目架构 2.Git版本管理 在IDEA中可以一键搭建并commit&#xff0c;当Git远程仓库搭建后就可以push 3.前后端联调 Builder注解&#xff1a; 加了注解后就可以通过这样的方式创建对象 接收传入的是dto对象&#xff0c;传出去的对象为vo对象 4.nginx反向…
阅读更多...
Java操作 elasticsearch 8.1，如何实现索引的重建？

Java操作 elasticsearch 8.1，如何实现索引的重建？

&#x1f3c6;本文收录于「Bug调优」专栏&#xff0c;主要记录项目实战过程中的Bug之前因后果及提供真实有效的解决方案&#xff0c;希望能够助你一臂之力&#xff0c;帮你早日登顶实现财富自由&#x1f680;&#xff1b;同时&#xff0c;欢迎大家关注&&收藏&&…
阅读更多...
最新文章

Copyright @ 2022~2023