Linux---进程信号

一、信号的概念

 信号是一种向目标进程发送通知消息的机制

信号的特性(可以结合红绿灯、防空警报等生活样例来理解)

1、在信号没有出现之前，我们就已经知道如何去处理信号，即我们认识信号

2、信号是异步产生的，即我们不知道它具体何时产生

3、当信号产生时，我们可以对它暂时忽略不做处理(比如我们外卖到了，但是你正在和朋友开黑，就会将外卖暂时搁置)

4、由于我们有时不会立即去执行信号，所以我们需要能储存信号

信号列表如下

一些补充的知识

二、信号的产生

 1、通过键盘进行信号的产生

解释如下

该系统调用接口可以自定义捕捉信号的行为，将signum信号的默认行为改为handler

//process.cc
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>

void handler(int signo)
{
    std::cout<<"发送了一个2号信号"<<std::endl;
    exit(1);
}

int main()
{
    signal(2,handler);
    std::cout << "pid: " << getpid() << std::endl;
    while(1)
    {
        std::cout << "running" << std::endl;
        sleep(1);
    }
    return 0;
}

对信号的进一步理解

 man 7 singal  查看信号的默认行为

既然我们能通过signal系统调用将信号的默认方法改变，那么我们能否将所有能杀死进程的信号改掉，使得进程无法被终止呢？？？

 很显然是不行的，有些信号是无法被自定义捕捉，比如9号信号，保证了OS的安全

2、通过系统调用进行信号的产生

功能：向pid进程发送sig信号（kill命令就是调用的该系统调用）

举个例子(写一个自己的kill命令)

//test.c
#include <stdio.h>
#include <unistd.h>
int main()
{
    printf("%d\n",getpid());
    while(1)
    {
        printf("running\n");
        sleep(1);
    }
    return 0;
}

//mykill.cc
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>

int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        std::cout<<"\nUsage:" << argv[0] <<" -signnumber processid" << std::endl;
        return 0;
    }
    int signnumber = std::stoi(argv[1]+1);
    int pid = std::stoi(argv[2]);
    kill(pid, signnumber);
    return 0;
}

功能：向本进程发送sig信号

举个例子

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

void handler(int signo)
{
    std::cout<<"发送了一个" << signo <<"号信号"<<std::endl;
}

int main()
{
    signal(2,handler);
    while(1)
    {
        raise(2);
        sleep(1);
    }
    return 0;
}

功能：向本进程发送6号信号，且进程一定会终止

举个例子

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

void handler(int signo)
{
    std::cout<<"发送了一个" << signo <<"号信号"<<std::endl;
}

int main()
{
    std::cout << getpid() << std::endl;
    signal(6,handler);
    // abort();
    while(1)
    {
        std::cout << "running" << std::endl;
        sleep(1);
    }
    return 0;
}

3、通过硬件异常进行信号的产生

原理如下

那么除0异常是发送的哪个信号呢？是8号信号，验证如下

根据上图：发送的确实是8号信号，但现在还有一个问题，进程出异常，OS发送8号信号，可以理解，但是为什么它一直在打印呢，明明我的代码没有循环啊？

因为，原本的8号信号被自定义捕捉成了打印语句，导致进程无法退出，所以进程依旧会在等待队列中等待CPU调度，所以各种寄存器中存放的该进程相关的数据(即进程上下文)都会被保留，包括状态寄存器，而一旦该进程被调度，那么OS就又会检测到硬件错误，向进程发送8信号，如此反复，故有上面的现象发生。

(一旦进程退出，它的相关数据就会被丢弃，因为我们不在需要调度该进程了)

OS杀死进程，就是处理问题的方式之一

程序运行出现异常，如何做取决于用户，但一般都是要让进程退出的（注意：异常的处理，很多时候只是打印错误）

顺便说一下，*nullptr发送的信号是11号信号，本质是页表中没有该地址的物理地址的映射关系，引发的硬件错误

4、通过软件条件进行信号的产生

这个其实在之前的博客中就讲过一些示例，比如管道中只要读端关闭，写端还在写，OS就会向写端发送SIGPIPE，终止写端，它本质是因为OS的内核数据中发现该管道只被一个进程打开，所以发信号终止写端，不是硬件异常，而是软件条件产生的信号。又比如调试程序用的gdb向进程发送的SIGSTOP和SIGCONT都是软件条件产生的信号。

这里再介绍一个alarm函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟，也就是告诉内核在seconds秒之后给当前进程发送SIGALRM信号(14号信号)，该信号的默认处理动作是终止当前进程

 演示如下

上面两段代码都是设置了1秒的闹钟，确实时间到了，进程就终止了，但是两段代码cnt++的运行次数却是天差地别，唯一的区别就是有没有与外设进行IO交互，也证明了IO的效率很低

 

多次使用alarm函数，就是刷新闹钟，并返回之前闹钟剩余的时间，注意：alarm(0)不是设置0秒的闹钟，这个相当于清空之前的闹钟并返回之前闹钟剩余的时间

了解(扩展)---帮助理解alarm

这里讲讲alarm是如何实现的，首先每个进程都能设置闹钟，也就是说OS中可以存在多个闹钟，所以需要管理，即先描述在组织，所以我们要设计一个闹钟结构体，里面包含闹钟所属进程id，时间（用时间戳记录）等等（根据需求往里面加属性）。然后就是如何组织，即选择什么样的数据结构进行管理，这里可以选择用小堆，按照时间大小存放，如果时间堆顶闹钟的时间没到，说明所有的都没到，不做处理，如果时间到了，就拿出来处理。(当然这不一定是Linux中alarm的实现，这里只是提供思想，具体如何实现得根据需求)

core dump(核心转储) 

介绍：

分析core dump是Linux应用程序调试的一种有效方式，core dump又称为“核心转储”，是该进程实际使用的物理内存的“快照”。分析core dump文件可以获取应用程序崩溃时的现场信息，如程序运行时的CPU寄存器值、堆栈指针、栈数据、函数调用栈等信息。

Core dump是Linux基于信号实现的。Linux中信号是一种异步事件处理机制，每种信号都对应有默认的异常处理操作，默认操作包括忽略该信号（Ignore）、暂停进程（Stop）、终止进程（Terminate）、终止并产生core dump（Core）等

这里也简单说一下，为什么有的信号终止进程需要核心转储，而有的不需要？

我们可以看一下那些不需要核心转储的终止信号，如SIGKILL，它其实并不是进程出现异常而将进程杀死，更类似于用户强制终止进程，也就是说进程本身并没有问题(或者出错原因很明显)，所以我们不需要core dump再去分析异常，但是像SIGSEGV信号，即段错误信号，我们只能知道是内存出现问题，但是具体是数组越界还是其他什么问题引发的我们并不清楚，所以我们需要core dump帮助我们去分析。

但其实通过上面我们的示例代码和结果截图，我们会发现，Term/Core的功能好像都一样，只是终止进程，并没有产生core dump文件，这是什么原因呢？

因为核心转储的文件太大了，我们用的是服务器，默认将core dump大小设置为0，即不生成核心转储，防止服务器被写满（虚拟机应该是开启的）当然可以通过指令打开，如下

注意：核心转储只能在对应的shell中生成，即哪个shell设置了core dump的大小，哪个shell跑程序收到异常才会生核心转储文件

上面的短短5行代码，就需要生成55万字节的文件，如果代码在多一点，文件只会更大，所以为了保证服务的安全，系统默认将core dump文件大小设置为0

那么核心转储的文件有什么用呢？

三、信号存储

信号的相关概念

  • 实际执行信号的处理动作称为信号递达(Delivery)
  • 信号从产生到递达之间的状态，称为信号未决(Pending)---即在信号位图中
  • 进程可以选择阻塞 (Block )某个信号---未决之后，暂时不递达

被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作
注意：阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作

如何在OS中体现上面说的三个概念---递达、未决、阻塞？？

  • 每个信号都有两个标志位分别表示阻塞(block)和未决(pending)，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。在上图的例子中，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。
  • SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。
  • SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。不讨论实时信号

四、信号阻塞

sigset_t

未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态，在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞，而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask)，这里的“屏蔽”应该理解为阻塞而不是忽略

信号集操作函数

int sigemptyset(sigset_t *set);将所有信号的对应bit清零，表示该信号集不包含任何有效信号
int sigfillset(sigset_t *set);将所有信号的对应bit置1，表示该信号集的有效信号包括系统支持的所有信号
int sigaddset (sigset_t *set, int signo);在该信号集中添加某种有效信号
int sigdelset(sigset_t *set, int signo);在该信号集中删除某种有效信号
int sigismember（const sigset_t *set, int signo);用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-1

注意：在使用sigset_ t类型的变量之前，一定要调用sigemptyset或sigfillset做初始化，使信号集处于确定的状态

 sigprocmask

功能介绍：如果oset是非空指针，则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。假设当前的信号屏蔽字为mask，下表说明了how参数的可选值

SIG_BLOCKset包含我们希望添加到当前信号屏蔽字的信号，相当于mask = mask|set
SIG_UNBLOCKset包含我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask = mask&~set
SIG_SETMASK设置当前信号屏蔽字为set所指向的值，相当于mask=set

如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达

演示如下

当然可能有人会说，既然能屏蔽信号，我们能不能将所有的信号全部屏蔽？？？

当然不行，跟有些信号无法被自定义捕捉是一个道理，如9号信号，这里就不验证了

 sigpending

读取当前进程的未决信号集，通过set参数传出。调用成功则返回0，出错则返回-1

演示从阻塞到递达的过程，如下

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

void handler(int signo)
{
    std::cout << "接收到" << signo << "信号" << std::endl;
}

void Printf_Pending(const sigset_t &pending)
{
    for (int i = 31; i >= 1; i--)
    {
        if (sigismember(&pending, i))
            std::cout << 1;
        else
            std::cout << 0;
    }
    std::cout << "\n";
}

int main()
{
    std::cout << "pid: " << getpid() << std::endl;
    signal(2, handler);
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, 2);
    sigprocmask(SIG_BLOCK, &set, nullptr); // 屏蔽2号信号
    std::cout << "屏蔽了2号信号" << std::endl;

    int cnt = 0;
    while (1)
    {
        sigset_t pending;
        sigpending(&pending);
        Printf_Pending(pending);
        sleep(1);
        cnt++;
        if (cnt == 10)
        {
            std::cout << "解除对2号信号的阻塞" << std::endl;
            sigprocmask(SIG_UNBLOCK, &set, nullptr);
        }
    }
    return 0;
}

这里有一个问题：pending位图的置0操作和信号的递达，谁先发生？？？

我们可以在handler方法中打印pending位图，如果已经为0，则置0操作先发生，反之，相反

显然，我们是先将pending位图的对应信号比特位置0，在执行信号的递达操作

五、信号的捕捉

信号在什么时候被处理？

--- 进程从内核态返回用户态的时候，进行信号的检测和递达

  • 用户态是一种受控的状态，能够访问的资源是有限的
  • 内核态是一种OS的共工作状态，能访问大部分系统资源

系统调用的背后，就包含了身份的变化！！！

补充一些进程地址空间的内容

内核空间对应的页表和OS资源只需要一份，因为所有的进程都需要，就像动态库资源我们只要加载一份就行，需要的就去映射。所以CPU在任何时间都能访问OS

可能有人会觉得：如果我的程序中只是在死循环的打印语句，没有进行系统调用，那么信号是不是就被处理了？

当然不是，进程是要被OS调度切换的，而当进程被放在CPU上执行时，本质就已经完成了从OS(内核)到用户的转换，所以信号有无数次机会被检测处理

Sigaction

#include <signal.h>
int sigaction(int signo，const struct sigaction *act，struct sigaction *oact);

  • 功能：可以读取和修改与指定信号相关联的处理动作。调用成功返回0，出错返回-1
  • 参数：signo是指定信号的编号。若act指针非空，则根据act修改该信号的处理动作。若oact指针非空，则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体

（只关注被框出来的两个成员）

将sa_handler赋值为常数SIG_IGN表示忽略信号，赋值为常数SIG_DFL表示执行系统默认动作，赋值为一个函数指针表示用自定义函数捕捉信号。和signal函数的第二个参数类似

当某个信号的处理函数被调用时，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时自动恢复原来的信号屏蔽字。sa_flags字段包含一些选项，这里我们不关心所以把sa_flags设为0，sa_sigaction是实时信号的处理函数

演示如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void Printf_Pending(const sigset_t &pending)
{
    for (int i = 31; i >= 1; i--)
    {
        if (sigismember(&pending, i))
            std::cout << 1;
        else
            std::cout << 0;
    }
    std::cout << "\n";
}

void handler(int signo)
{
    std::cout << "接收到" << signo << "信号" << std::endl;
    while (1)
    {
        sigset_t pending;
        sigpending(&pending);
        Printf_Pending(pending);
        sleep(1);
    }
}

int main()
{
    std::cout << "pid: " << getpid() << std::endl;
    struct sigaction act, oact;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 3);
    sigaction(2, &act, &oact);

    while (1)
        sleep(1);
    return 0;
}

显然，sigaction函数不仅将自定义捕捉的2号信号在运行时自行屏蔽，而且可以通过sa_mask同时将其他的信号也屏蔽，注意这些屏蔽会在2号信号处理结束返回后解除

并且返回后，它还是会去检测是否有信号需要被递达，至于信号被处理的顺序和信号优先级有关(这里就不演示了)

 六、信号的补充问题(了解)

可重入函数

即可以重复进入的函数，什么意思？举个简单的例子，我们学过用fork创建子进程，当父进程和子进程同时执行printf语句时，就有可能在屏幕上出现交替打印的情况，导致输出的数据不符合预期，这就说明printf语句是不可重入函数。反之，如果多个执行流可以同时进入一个函数，且不发生错误，就是可重入函数。

注意：可重入和不可重入是函数的一个特征，并不能作为评判函数好坏的标准。一般来说，使用公共资源的函数都是不可重入函数。

 volatile---保持内存的可见性

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
int flag = 0;
void handler(int sigo)
{
    flag = 1;
    std::cout << "flag changed to :" << flag << std::endl;
}

int main()
{
    signal(2, handler);
    std::cout << "flag:" << flag << std::endl;
    while (!flag)
        ;
    std::cout << "flag:" << flag << std::endl;
    return 0;
}

如果是正常编译程序，不会有问题，一旦优化(相当于release版)就会出bug为什么？

因为flag变量被优化后直接放到了CPU的寄存器中，在信号处理时，我们改变的flag是内存中的flag，并不会改变寄存器中的flag，所以进程无法结束

我们可以给flag加volatile关键字，保证内存的可见性，即保证该变量一直从内存中读取得到

SIGCHLD信号(17号信号)

子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自 定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了,子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可

1、验证子进程终止是否会向父进程发送SIGCHLD信号

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <sys/types.h>

void handler(int signo)
{
    std::cout << "get " << signo << " sign" << std::endl;
}

int main()
{
    signal(SIGCHLD, handler);
    pid_t id = fork();
    if(id==0)
    {
        std::cout<<"child running"<<std::endl;
        sleep(5);
        exit(1);
    }

    wait(nullptr);
    return 0;
}

2、在handler函数中回收子进程

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <sys/types.h>

void handler(int signo)
{
    std::cout << "get " << signo << " sign" << std::endl;
    wait(nullptr);
}

int main()
{
    signal(SIGCHLD, handler);
    std::cout << "father pid: " << getpid() << std::endl;

    pid_t id = fork();
    if (id == 0)
    {
        std::cout << "child pid: " << getpid() << std::endl;
        std::cout << "child running" << std::endl;
        sleep(5);
        exit(1);
    }

    return 0;
}

上面的是针对只有一个子进程的情况，但是如果有多个进程呢？

我们知道如果多个子进程同时退出，发送17号信号，父进程的pending表只会记录一次17号信号，也就只会执行一次wait函数，所以有的子进程就会处于僵尸状态，那我们该如何做？

有人可能觉得用循环就行，如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>

void handler(int signo)
{
    std::cout << "get " << signo << " sign" << std::endl;
    pid_t id;
    while ((id = wait(nullptr)))
    {
        std::cout << "child pid: " << id << " exit" << std::endl;
        if (id < 0)
            break;
    }
}

int main()
{
    signal(SIGCHLD, handler);
    for (int i = 0; i < 5; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            std::cout << "child is running" << std::endl;
            sleep(5);
            exit(1);
        }
    }

    while(1) sleep(1);
    return 0;
}

事实证明也确实行，但是这是所有子进程都结束的情况，如果有一部分子进程终止，另一部分子进程一直在运行，那么我们就无法跳出循环，因为wait是阻塞等待，它可以去查看是否有进程还没终止，这样就会一直在阻塞。

所以用非阻塞等待才是最恰当的，如下

void handler(int signo)
{
    std::cout << "get " << signo << " sign" << std::endl;
    pid_t id;
    while ((id = waitpid(-1, nullptr, WNOHANG)) > 0)
    {
        std::cout << "child pid: " << id << " exit" << std::endl;
    }
}

当然，如果不关心子进程的返回信息，也可以直接忽略该信号，子进程会自动被清理。如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 5; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            std::cout << "child is running" << std::endl;
            sleep(5);
            exit(1);
        }
    }
    while(1) sleep(1);
    return 0;
}

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

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

相关文章

官宣 | 凯琦供应链成为亚马逊SPN物流服务商！

官宣 | 凯琦供应链成为亚马逊SPN物流服务商！

再播一条喜讯&#xff01;在亚马逊官方平台的筛选考核下&#xff0c;凯琦供应链近日正式入驻亚马逊SPN服务商平台&#xff0c;成为亚马逊SPN第三方承运商。 这也标志着凯琦9年来在FBA物流领域的服务质量得到了客户、官方及行业的广泛认可&#xff0c;未来凯琦将继续为亚马逊卖家…
阅读更多...
LLM 聊天对话界面chatwebui 增加实时语音tts功能

LLM 聊天对话界面chatwebui 增加实时语音tts功能

类似豆包聊天，可以实时语音回复 1、聊天界面 streamlit页面 参考界面：https://blog.csdn.net/weixin_42357472/article/details/133199866 stream_web.py 2、 增加实时语音tts功能（接入melotts api服务） 参考：https://blog.csdn.net/weixin_42357472/article/detai…
阅读更多...
Python + Selenium —— 下拉菜单处理！

Python + Selenium —— 下拉菜单处理！

传统的下拉菜单 Select 元素&#xff0c;由一个 Select 一系列的 option 元素构成。 <select id"source" name"source"><option value"">--请选择--</option><option value"1001">网络营销</option>&…
阅读更多...
全部都有的子序列

全部都有的子序列

思路&#xff08;双指针&#xff09; 先使用Set来存储总共有多少不同的数字&#xff0c;然后我们使用快慢指针去遍历数组&#xff0c;快指针每次遍历到一个数&#xff0c;将其加入到哈希表&#xff0c;哈希表使用pair存储&#xff0c;第一个元素存数字&#xff0c;第二个元素存…
阅读更多...
Ban for 1 day （wangzherongyao) 2024.03.02

Ban for 1 day （wangzherongyao) 2024.03.02

王者荣耀禁赛1天 单排真的要保持【心态】&#xff0c;即便队友是这种&#xff0c;也要克制&#xff0c;不然接着就开始【连败】。 为什么我玩射手和法师喜欢提早第一件第二件出【梦魇】和【制裁】&#xff0c;因为对面有回复英雄就是一个风险&#xff0c;早做应对&#xff01;…
阅读更多...
SpringCloudNacos注册中心服务分级存储模型

SpringCloudNacos注册中心服务分级存储模型

文章目录 服务分级存储模型概述配置集群同集群优先的负载均衡 权重配置总结 之前对 Nacos注册中心入门 已经做了演示. 这篇文章对 Nacos 的服务分级存储模型做理论与实践. 服务分级存储模型概述 一个服务可以有多个实例&#xff0c;例如我们的 user-server&#xff0c;可以有:…
阅读更多...
【和鲸冬令营】通过数据打造爆款社交APP用户行为分析报告

【和鲸冬令营】通过数据打造爆款社交APP用户行为分析报告

【&#x1f40b;和鲸冬令营】通过数据打造爆款社交APP用户行为分析报告 文章目录 【&#x1f40b;和鲸冬令营】通过数据打造爆款社交APP用户行为分析报告1 业务背景2 数据说明3 数据探索性分析4 用户行为分析4.1 用户属性与行为关系分析4.2 转化行为在不同用户属性群体中的分布…
阅读更多...
MySQL中json类型的字段

MySQL中json类型的字段

有些很复杂的信息&#xff0c;我们一般会用扩展字段传一个json串&#xff0c;字段一般用text类型存在数据库。mysql5.7以后支持json类型的字段&#xff0c;还可以进行sql查询与修改json内的某个字段的能力。 1.json字段定义 ip_info json DEFAULT NULL COMMENT ip信息, 2.按…
阅读更多...
【rabbit robot】控制代码.C解读

【rabbit robot】控制代码.C解读

使用 MATLAB Coder 工具箱直接转换为C语言后即可直接在实机代码中使用&#xff0c;在本项目主控代码中可以找到同名文件,除main函数和PID函数&#xff0c;其余都是MATLAB生成的。debug函数不用管&#xff0c;用于调试。 平衡算法主要参考了这个专栏文章&#xff0c;仅有少许不…
阅读更多...
【LeetCode:230. 二叉搜索树中第K小的元素 + 二叉树 + 递归】

【LeetCode:230. 二叉搜索树中第K小的元素 + 二叉树 + 递归】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
YOLOv9有效改进|使用空间和通道重建卷积SCConv改进RepNCSPELAN4

YOLOv9有效改进|使用空间和通道重建卷积SCConv改进RepNCSPELAN4

专栏介绍&#xff1a;YOLOv9改进系列 | 包含深度学习最新创新&#xff0c;主力高效涨点&#xff01;&#xff01;&#xff01; 一、改进点介绍 SCConv是一种即插即用的空间和通道重建卷积。 RepNCSPELAN4是YOLOv9中的特征提取模块&#xff0c;类似YOLOv5和v8中的C2f与C3模块。 …
阅读更多...
多线程（进阶四：线程安全的集合类）

多线程（进阶四：线程安全的集合类）

目录 一、多线程环境使用ArrayList 二、多线程环境使用队列 三、多线程环境使用哈希表 1、HashMap 2、Hashtable 3、ConcurrentHashMap (1)缩小了锁的粒度 (2)充分使用了CAS原子操作&#xff0c;减少一些加锁 (3)针对扩容操作的一些优化&#xff08;化整为零&#xff…
阅读更多...
【中英对照】【自译】【精华】麻省理工学院MIT技术双月刊（Bimonthly MIT Technology Review）2024年3/4月刊内容概览

【中英对照】【自译】【精华】麻省理工学院MIT技术双月刊（Bimonthly MIT Technology Review）2024年3/4月刊内容概览

一、说明 Notation 仅供学习、参考&#xff0c;请勿用于商业行为。 二、本期封面、封底 Covers 本期杂志购于新加坡樟宜机场Changi Airport Singapore&#xff0c;售价为20.50新元。 本期仍然关注伦敦的AI大会。&#xff08;笔者十分想去&#xff0c;在伦敦和MIT校园均设有会…
阅读更多...
【每日一题】3.2 求逆序对

【每日一题】3.2 求逆序对

题目描述 给定一个长度为 n的整数数列&#xff0c;请你计算数列中的逆序对的数量。 逆序对的定义如下&#xff1a;对于数列的第 i个和第 j个元素&#xff0c;如果满足 i<j 且 a[i]>a[j]&#xff0c;则其为一个逆序对&#xff1b;否则不是。 输入格式 第一行包含整数 n…
阅读更多...
MQL5学习之RSI指标编写

MQL5学习之RSI指标编写

研究MT5时发现MQL5这个指标编写功能很强大&#xff0c;应该是碾压国内所有的指标系统&#xff0c;不过这个东西相对复杂很多&#xff0c;比通达信公式不知复杂几许&#xff0c;看起来和C语法接近&#xff0c;倒是比较适合自己。试着玩一下&#xff0c;发现还是有点难度的。索性…
阅读更多...
Java输入输出流详细解析

Java输入输出流详细解析

Java I/O&#xff08;输入/输出&#xff09;主要被用来处理输入数据和输出结果。 在Java中&#xff0c;输入/输出操作被当作流&#xff08;Stream&#xff09;进行处理。流是一个连续的数据流入或数据流出的通道。流操作在Java中主要可以分为两种类型&#xff1a;字节流和字符…
阅读更多...
代码随想录【数组】 ---- 二分查找

代码随想录【数组】 ---- 二分查找

代码随想录【数组】 ---- 二分查找 704.二分查找方法一&#xff1a;二分查找 35.搜索插入位置方法一&#xff1a;二分查找 34.在排序数组中查找元素的第一个和最后一个位置方法一&#xff1a;二分查找 69.x的平方根方法一&#xff1a;袖珍计算器方法二&#xff1a;二分查找方法…
阅读更多...
黑马JUC笔记

黑马JUC笔记

黑马JUC笔记 1.概览 2.进程与线程 2.1 进程与线程 进程 程序由指令和数据组成&#xff0c;但这些指令要运行&#xff0c;数据要读写&#xff0c;就必须将指令加载至 CPU&#xff0c;数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管…
阅读更多...
qsort函数的模拟实现（冒泡排序模拟）

qsort函数的模拟实现（冒泡排序模拟）

冒泡排序&#xff1a; 从第一个元素开始&#xff0c;依次比较相邻的两个元素&#xff0c;如果顺序不对就交换它们。 经过一轮遍历后&#xff0c;最大&#xff08;或最小&#xff09;的元素会排在最后。 重复进行上述步骤&#xff0c;直到没有任何元素需要交换&#xff0c;即…
阅读更多...
【打工日常】使用docker部署在线Photopea用于linux下替代ps

【打工日常】使用docker部署在线Photopea用于linux下替代ps

一、Photopea介绍 linux没有ps适配&#xff0c;对于有时候工作来说确实不方便&#xff0c;我找了很久&#xff0c;才找到了一款功能可以跟ps接近的在线软件&#xff0c;使用docker部署就可以了。它是ps的最佳替代品之一&#xff0c;其界面几乎与ps相同&#xff0c;只不过它是在…
阅读更多...
最新文章

Copyright @ 2022~2023