Linux系统编程 day07 信号

Linux系统编程 day07 信号

  • 1. 信号的介绍以及信号的机制
  • 2. 信号相关函数
    • 2.1 `signal`
    • 2.2 `kill`
    • 2.3 `abort`和`raise`
    • 2.4 `alarm`
    • 2.5 `setitimer`
  • 3. 信号集
  • 4. 信号捕捉函数
  • 6. `SIGCHLD`信号
  • 7. `SIGUSR1`与`SIGUSR2`

1. 信号的介绍以及信号的机制

信号是信息的载体，在Linux/Unix环境下，信号是一种很重要的通信手段。信号通信的方式简单，但是不能携带大量的信息，信号是满足某个特定的条件才会产生的。

在Linux中，进程A给进程B发送信号，进程B收到信号之前执行自己的代码，收到信号后，不管执行到应用程序的什么位置，都要暂停运行，去处理信号，处理完毕后再继续执行。信号是在软件的层面上实现的中断，早期被称为软中断。每一个进程收到的信号都是由内核负责发送的。信号的发送过程如下：

在这里插入图片描述
信号的状态有三种，分别是产生、未决、递达。信号的产生由以下的几种方式：

  • 按键产生，如：Ctrl + C（SIGINT）、Ctrl + Z （SIGSTOP）、Ctrl + \ （SIGTERM）。
  • 系统调用产生，如：调用kill 、raise、abort。
  • 软件条件产生，如：定时器alarm。
  • 硬件异常产生，如：非法访问内存（段错误）、除0（浮点数例外）、内存对齐出错（总线错误）。
  • 命令产生，如：kill命令。

信号的未决状态时是信号产生和信号递达之间的状态，主要是由于阻塞导致了该状态，后面我们会用sigpromask去对某个信号集进行阻塞等操作。信号的递达是信号递达并且到达该进程。

进程收到了信号之后，就会对信号进行相应的处理。信号处理默认动作有以下几种方式：

在这里插入图片描述

处理方式处理结果
Term默认行为是终止进程
Ign默认行为是忽略信号
Core默认行为是终止进程并生成core文件
Stop默认行为是暂停进程
Cont默认行为是如果进程当前状态为暂停则继续运行进程

当然，除了默认处理之外我们还可以捕捉信号调用用户的自定义处理函数。由于信号的发送是需要由用户态切换到内核态，处理也是需要进入内核态，所以用信号这种实现进程间通信的手段会导致信号有很强的延时性。虽然有延时，但是这个时间对于用户来说是非常短的，用户基本上察觉不到。

进程的相关信息存储在PCB中，在PCB中有阻塞信号集和未决信号集。阻塞信号集的作用是对信号进行阻塞，若一个信号被阻塞之后如果收到了该信号就会留在未决信号集中，不会被处理。未决信号集是用于存储需要处理的信号，这些信号因为某些原因不能抵达，在解决屏蔽之前，信号都是一直处于未决状态。当信号被处理，这信号会从未决信号集中消失。

信号有四要素，分别是信号的编号、信号的名称、产生信号的事件和默认的处理动作。其中，信号编号为1~31之间的信号为常规信号，也称为普通信号或者标准信号。34~64之间的信号称为实时信号，与驱动编程和硬件相关。下面是信号的四要素表：

在这里插入图片描述在这里插入图片描述
信号编号表：

在这里插入图片描述

从上面可以看到这些信号的编号在不同的操作系统架构中是不一样的，因此我们使用信号的时候应该使用信号的名称。在上面的所有信号之中，特别需要注意SIGKILL和SIGSTOP信号是不能被捕获和阻塞或者是忽略的。

在系统编程中，我们常用的信号有SIGINT、SIGQUIT、SIGKILL、SIGSEGV、SIGUSR1、SIGUSR2、SIGPIPE、SIGALRM、SIGTERM、SIGCHLD、SIGSTOP、SIGCONT。

这些信号的含义如下：

常用信号含义
SIGINT按键中断
SIGQUIT退出
SIGKILL杀死
SIGSEGV内存溢出非法操作内存等
SIGUSR1用户使用自定义信号
SIGUSR2用户使用自定义信号
SIGPIPE管道破裂
SIGALRM定时器信号
SIGTERM终止信号
SIGCHLD子进程死亡、暂停、继续时给父进程发送的信号
SIGSTOP暂停进程
SIGCONT继续运行暂停的进程

2. 信号相关函数

2.1 signal

该函数用于注册信号捕捉函数，函数的原型如下：

#include <signal.h>// 信号处理函数类型
typedef void (*sighandler_t)(int);// 作用: 注册信号捕捉函数
// 返回值: 以前信号的处理函数指针
// 参数: signum: 信号编号
//       handler: 信号处理函数
sighandler_t signal(int signum, sighandler_t handler);

该函数的使用示例如下：

// signal函数测试--注册信号处理函数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);
}int main()
{// 注册信号处理函数signal(SIGINT, sighandler);sleep(200);return 0;
}

需要注意的是signal函数的行为在不同的UNIX版本之间是不同的，在不同的Linux版本之间也是不同的，应该避免是用它，后续会用sigaction函数取代。

2.2 kill

kill函数用于给指定的进程发送指定的信号。该函数的原型为：

#include <sys/types.h>
#include <signal.h>// 作用: 给指定进程发送指定信号
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数:  pid: 进程号
//             pid > 0: 发送信号给指定进程。
//             pid = 0: 发送信号给调用kill进程属于同一进程组的
//                      所有进程。
//             pid < -1: 发送给pid绝对值对应的进程组。
//             pid = -1: 发送给进程有权限发送的系统中所有进程。
//        sig: 信号
int kill(pid_t pid, int sig);

函数中的sig信号参数不推荐使用数字，应该使用宏名，因为不同的操作系统信号编号可能不一样，但名称不一样。

在Linux中，每一个进程都属于一个进程组，进程组是一个或者多个进程的集合，他们是相互关联的，共同完成一个实体任务，每一个进程都有一个进程组长，默认进程组ID与进程组组长ID相同。

关于kill的示例代码如下：

// kill函数测试--发送信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);kill(getpid(), SIGKILL);
}int main()
{// 注册信号处理函数signal(SIGINT, sighandler);while(1){sleep(1);kill(getpid(), SIGINT);}return 0;
}

2.3 abort和raise

这两个函数是进程自己给自己发送信号，其中abort用于给自己发送异常终止信号SIGABRT，并会产生core文件，而raise函数是用于给自己发送指定信号。这两个函数的原型如下：

#include <signal.h>// 作用: 给当前进程发送指定信号，自己给自己发
// 返回值: 成功返回0，失败返回非0值
// 参数: sig: 信号编号
int raise(int sig);

#include <stdlib.h>// 作用: 给自己发送异常终止信号SIGABRT，并产生core文件
void abort(void);

这两个函数的功能都可以使用kill函数实现。这两个函数的示例代码如下：

raise函数测试

// raise函数测试 -- 给自己发送指定信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);raise(SIGKILL);
}int main()
{// 注册信号处理函数signal(SIGINT, sighandler);while(1){raise(SIGINT);}return 0;
}

abort函数测试

// abort函数测试 -- 给自己发送异常终止信号
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>// 注册信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);raise(SIGSTOP);
}int main()
{// 注册信号处理函数signal(SIGABRT, sighandler);abort();return 0;
}

2.4 alarm

该函数主要是用于设置定时器。函数的原型如下：

#include <unistd.h>// 作用: 设置定时器（闹钟），在指定seconds之后，内核会给当前进程发送
//       SIGALRM信号。进程收到该信号之后，默认动作为终止。每一个进程
//       都有且只有唯一的一个定时器。
// 返回值: 返回0或者剩余的秒数，无失败的返回
// 参数: seconds: 秒数
unsigned int alarm(unsigned int seconds);

该函数的如果把参数设置为0就表示取消定时器，也就是alarm(0)。alarm函数使用的是自然定时，与进程的状态无关，无论进程处于什么状态alarm都计时。该函数的示例代码如下：

// alarm函数测试--设置定时器
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>int main()
{// 设置定时器int ret = alarm(5);printf("ret = [%d]\n", ret);sleep(2);ret = alarm(4);printf("ret = [%d]\n", ret);sleep(1);ret = alarm(4);printf("ret = [%d]\n", ret);while(1){sleep(1000);}return 0;
}

2.5 setitimer

setitimer函数也是用于设置定时器的，可以代替alarm函数。该函数的精确到微妙，可以实现周期定时。函数的原型如下：

#include <sys/time.h>// 作用: 设置定时器，精度为微妙，可以实现周期定时。
// 返回值: 成功返回0，失败返回-1并设置errno。
// 参数: which: 定时方式。
//       new_value: 负责设定timeout时间
//       old_value: 存放旧的timeout时间，一般指定为NULL。 
int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);// 参数的结构体
struct itimerval {struct timeval it_interval; // 闹钟触发周期struct timeval it_value;    // 闹钟第一次触发时间
};struct timeval {time_t      tv_sec;         // 秒suseconds_t tv_usec;        // 微妙
};

其中定时方式主要有以下几种：

定时方式宏名信号含义
自然定时ITIMER_REALSIGALRM计算自然时间
虚拟空间计时（用户空间）ITIMER_VIRTUALSIGVTALRM只计算占用CPU的时间
运行时计时（用户 + 内核）ITIMER_PROFSIGPROF计算占用CPU以及执行系统调用的时间

该函数的使用示例如下：

// setitimer函数测试
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);
}int main()
{// 注册信号处理函数signal(SIGALRM, sighandler);// 设置周期时间struct itimerval tm;tm.it_interval.tv_sec = 1;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){sleep(1);}return 0;
}

3. 信号集

信号集主要是两个信号集。第一个是未决信号集，该信号集存放了当前进程要阻塞的信号。第二个是阻塞信号集，该信号集存放了当前进程中还处于未决状态的信号。这两个集合都存储在PCB中。

在一个进程运行的时候，如果该进程收到了一个信号A，则这个信号首先会被保存到未决信号集中对应的信号编号的存储位置，将该位置置为1，此时该信号处于未决状态。当要处理这个信号的时候，会去检查阻塞信号集中对应的信号编号的存储位置上是否为0，若为1表示需要阻塞该信号，则信号不会被处理，若为0则表示该信号不被阻塞。当未决信号集的信号没有被阻塞被处理之后，未决信号集的信号编号对应的存储位置会被重置为0。

信号集在Linux中使用sigset_t进行定义。该类型是一个结构体，结构体定义如下：

#ifndef ____sigset_t_defined
#define ____sigset_t_defined#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;#endif

由于信号集属于内核的一块区域，所以用户不能直接操作内核空间，因此我们需要使用信号集相关的一些接口函数完成对信号集的相关操作。

接下来看一些信号集的相关函数，信号集相关函数原型如下：

#include <signal.h>// 作用: 将某个信号集清0
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
int sigemptyset(sigset_t *set);// 作用: 将某个信号集置1
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
int sigfillset(sigset_t *set);// 作用: 将某个信号加入到信号集中
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigaddset(sigset_t *set, int signum);// 作用: 将某个信号清出信号集
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigdelset(sigset_t *set, int signum);// 作用: 判断某个信号是否在信号集中
// 返回值: 存在返回1，不存在返回0，失败返回-1并设置errno
// 参数: set: 信号集
//      signum: 信号编号
int sigismember(const sigset_t *set, int signum);
#include <signal.h>// 作用: 用于屏蔽信号，解除屏蔽信号
// 返回值: 成功返回0，失败返回-1并设置error
// 参数: how: 参数取值决定函数的作用，how的取值有以下:
//              SIG_BLOCK: 设置屏蔽信号，set为需要屏蔽的信号
//              SIG_UNBLOCK: 设置解除屏蔽信号，set表示要解除屏蔽信号
//              SIG_SETMASK: set用于代替原始屏蔽集的新屏蔽集
//       set: 需要设置的信号集
//       oldset: 在设置操作之前的信号集 
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

#include <signal.h>// 作用: 读取当前进程的未决信号集
// 返回值: 成功返回0，失败返回-1并设置errno
// 作用: set: 信号集
int sigpending(sigset_t *set);

接下来使用一个例子来说明以下信号集相关函数的使用，该例子的作用是将当前进程未决信号集中的常用信号集打印出来。

// 信号集相关函数测试
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <signal.h>
#include <unistd.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);
}int main()
{// 注册信号处理函数signal(SIGINT, sighandler);signal(SIGQUIT, sighandler);// 定义信号集sigset_t set; // 设置的信号集sigset_t pending; // 未决信号集sigset_t oldset; // 保存之前的信号集// 初始化信号集sigemptyset(&set);sigemptyset(&oldset);sigemptyset(&pending);// 将SIGINT和SIGQUIT加入到信号集中sigaddset(&set, SIGINT);sigaddset(&set, SIGQUIT);// 将SIGINT和SIGQUIT加入到阻塞信号集中// sigprocmask(SIG_BLOCK, &set, NULL);sigprocmask(SIG_BLOCK, &set, &oldset);int j = 1;while(1){// 获取未决信号集sigpending(&pending);for(int i = 1; i < 32; i ++){// 判断某个信号是否位于信号集中if(sigismember(&pending, i)){printf("1");}else {printf("0");}}printf("\n");if(j ++ % 10 == 0){// 解除阻塞// sigprocmask(SIG_UNBLOCK, &set, NULL);sigprocmask(SIG_UNBLOCK, &set, &oldset);}else{// 阻塞sigprocmask(SIG_BLOCK, &set, NULL);}sleep(1);}return 0;
}

程序的运行结果如下：

在这里插入图片描述

4. 信号捕捉函数

这里的信号处理函数是说的sigaction，该函数的作用和signal一样。不同的signal函数在不同的Unix或者Linux下其行为可能是不一样的，而sigaction的行为都是一样的，想要做一个跨平台的程序一般使用sigaction函数。该函数的原型如下：

#include <signal.h>// 作用: 注册一个信号处理函数
// 返回值: 成功返回0，失败返回-1并设置errno
// 参数: signum: 捕捉的信号
//       act: 新的处理方式
//       oldact: 旧的处理方式
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);// struct sigaction 定义如下
struct sigaction {// 信号处理函数void     (*sa_handler)(int); // 信号处理函数，一般不用这个void     (*sa_sigaction)(int, siginfo_t *, void *);// 处理期间需要阻塞的信号sigset_t   sa_mask;// 默认标识，通常设置为0int        sa_flags;// 已丢弃不用void     (*sa_restorer)(void);
};

在上面结构体的sa_handler，表示指定信号捕捉后处理的函数名，也可以赋值为SIG_IGN表示忽略，SIG_DFL表示执行默认动作。sa_mask用于指定在信号处理函数执行期间需要被屏蔽的信号，特别是当某个信号被处理的时候，它自身会被自动放入到进程的信号掩码，因此在信号处理函数执行期间这个信号不会再度发生。需要注意的是sa_mask只在处理函数调用期间屏蔽生效，是一个临时性的设置。另外需要知道的是信号是不支持排队的。也就是在一个信号处理函数执行期间该函数接收到了很多个该信号，则信号处理函数处理完该信号之后只执行一次处理。

内核再执行信号处理函数的过程如下：

在这里插入图片描述
接下来给一个关于使用sigaction函数的例子。

// sigaction函数测试：信号捕获
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>// 信号处理函数
void sighandler(int signo)
{printf("signo = [%d]\n", signo);sleep(5);
}int main()
{// 注册信号处理函数struct sigaction act;act.sa_handler = sighandler; // 信号处理函数sigemptyset(&act.sa_mask);sigaddset(&act.sa_mask, SIGQUIT);  // 信号执行期间需要阻塞的信号act.sa_flags = 0;sigaction(SIGINT, &act, NULL); // 注册信号处理函数signal(SIGQUIT, sighandler);while(1){sleep(1);}return 0;
}

6. SIGCHLD信号

SIGCHLD信号主要是由子进程在一定条件下触发并由内核给父进程发送的信号，该信号的产生有三种情况：

  • 子进程结束的时候。
  • 子进程收到SIGSTOP信号。
  • 子进程停止时收到SIGCONT信号。

子进程退出之后，内核会给父进程发送SIGCHLD信号，因此我们可以用这个信号完成对子进程的回收。这样避免父进程一直阻塞等待而不能执行其它操作。在回收子进程的时候，我们需要考虑到有可能还没有完成信号注册的时候子进程就可能退出了，也有可能在SIGCHLD处理期间SIGCHLD再次产生了很多次，若不进行多次回收则会出现僵尸进程。

避免第一个问题的方法是在注册处理函数之前先对SIGCHLD信号进行阻塞；第二个问题的解决是使用循环进行多次回收。因此我们可以写出来以下用SIGCHLD函数完成子进程回收的例子。关于信号产生的条件可以自行验证。

// 使用SIGCHLD回收子进程的资源
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>// 注册信号处理函数
void sighandler(int signo)
{while(1){pid_t wpid = waitpid(-1, NULL, WNOHANG);if(wpid > 0){printf("Child pid = [%d] is dead\n", wpid);}else if(wpid == 0){printf("Child is living\n");break;}else if(wpid == -1){printf("No child is living\n");break;}}
}int main()
{// 在注册SIGCHLD之前阻塞SIGCHLD信号sigset_t  set;sigemptyset(&set);sigaddset(&set, SIGCHLD);sigprocmask(SIG_BLOCK, &set, NULL);// 创建子进程int i;for(i = 0; i < 3; i ++){pid_t pid = fork();if(pid < 0){perror("fork error");return -1;}else if(pid == 0){printf("Child: pid = [%d], fpid = [%d]\n", getpid(), getppid());break;}}if(i == 0){printf("I am child [%d]\n", getpid());sleep(2);}else if(i == 1){printf("I am child [%d]\n", getpid());sleep(1);}else if(i == 2){printf("I am child [%d]\n", getpid());sleep(2);}else if(i == 3){sleep(4);// 注册信号处理函数struct sigaction act;act.sa_handler = sighandler;sigemptyset(&act.sa_mask);act.sa_flags = 0;sigaction(SIGCHLD, &act, NULL);// 取消阻塞sigprocmask(SIG_UNBLOCK, &set, NULL);}return 0;
}

7. SIGUSR1与SIGUSR2

在系统编程的时候，我们不能随便乱使用kill函数去对某个进行发送一个系统的信号，因此操作系统提供用户两个信号使用。接下来我们使用这个两个信号完成两个进程交替数数。示例代码如下：

// 使用SIGUSR实现交替数数
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>int num = 0;
int flag;// 信号处理函数
void sigusr1handler(int signo)
{printf("USR1: [%d]\n", num);num += 2;flag = 0;sleep(1);
}void sigusr2handler(int signo)
{printf("USR2: [%d]\n", num);num += 2;flag = 0;sleep(1);
}int main()
{// 创建子进程pid_t pid = fork();if(pid < 0){perror("fork error");return -1;}else if(pid == 0){// 注册信号处理函数struct sigaction act;act.sa_handler = sigusr2handler;sigemptyset(&act.sa_mask);act.sa_flags = 0;sigaction(SIGUSR2, &act, NULL);num = 2;flag = 0;while(1){if(flag == 0){kill(getppid(), SIGUSR1);flag = 1;}}}else {// 注册信号处理函数struct sigaction act;act.sa_handler = sigusr1handler;sigemptyset(&act.sa_mask);act.sa_flags = 0;sigaction(SIGUSR1, &act, NULL);num = 1;flag = 1;while(1){if(flag == 0){kill(pid, SIGUSR2);flag = 1;}}}return 0;
}

运行结果为：

在这里插入图片描述
在上面的代码之中，我们分别通过信号处理函数来控制while循环中的if语句是否执行。两个进程分别互相发送信号就可以完成进程的交替输出。由于flag变量和num变量需要在信号处理函数中能够访问，所以定义成了全局变量。具体的运行过程可以通过分析程序结构理解理解。

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

JMeter从入门到精通

JMeter从入门到精通

1、 jmeter的介绍 jmeter也是一款接口测试工具&#xff0c;由java语言开发的&#xff0c;主要进行性能测试。 2、jmeter安装 jmeter官网下载链接&#xff1a; https://jmeter.apache.org/download_jmeter.cgi &#xff0c;查看是否安装成功【jmeter -v】 下载 java jdk1.8&…
阅读更多...
STM32 CUBEIDE Outline is disabled due to scalability mode

STM32 CUBEIDE Outline is disabled due to scalability mode

项目场景&#xff1a; 问题描述 Outline is disabled due to scalability mode 看不到函数 解决方案&#xff1a;
阅读更多...
ruoyi+Hadoop+hbase实现大数据存储查询

ruoyi+Hadoop+hbase实现大数据存储查询

前言 有个现实的需求&#xff0c;数据量可能在100亿条左右。现有的数据库是SQL Server&#xff0c;随着采集的数据不断的填充&#xff0c;查询的效率越来越慢&#xff08;现有的SQL Server查询已经需要数十秒钟的时间&#xff09;&#xff0c;看看有没有优化的方案。 考虑过S…
阅读更多...
LeetCode Hot100 3.无重复字符的最长子串

LeetCode Hot100 3.无重复字符的最长子串

题目&#xff1a; 给定一个字符串 s &#xff0c;请你找出其中不含有重复字符的 最长子串 的长度。 代码&#xff1a; class Solution {public int lengthOfLongestSubstring(String s) {char[] arr s.toCharArray(); // 转换成 char[] 加快效率&#xff08;忽略带来的空间…
阅读更多...
Java——TreeSet用法

Java——TreeSet用法

Java——TreeSet TreeSet 是 Java 中的一个有序集合类&#xff0c;它基于红黑树&#xff08;Red-Black Tree&#xff09;实现。 下面详细介绍 TreeSet 的用法和特点&#xff1a; 有序性&#xff1a;TreeSet 中的元素按照自然顺序或者通过自定义的比较器进行排序。它保证了元素…
阅读更多...
【C++ Primer Plus学习记录】循环和文本输入

【C++ Primer Plus学习记录】循环和文本输入

目录 1.使用原始的cin进行输入 2.使用cin.get(char)进行补救 3.使用哪一个cin.get() 4.文件尾条件 循环完后的一项最常见、最重要的任务&#xff1a;逐字符地读取来自文件或键盘的文本。 cin对象支持3种不同模式的单字符输入&#xff0c;其用户接口各不相同。下面介绍如何…
阅读更多...
LabVIEW开发自适应降噪ANC

LabVIEW开发自适应降噪ANC

LabVIEW开发自适应降噪ANC 在许多情况下&#xff0c;信号很嘈杂&#xff0c;必须消除噪声。自适应降噪&#xff08;ANC&#xff09;是可用于消除信号噪声的主要实时方法之一。可以使用LabVIEW自适应滤滤器工具包来设计ANC应用程序。本文介绍使用自适应筛选器工具包的ANC的一些…
阅读更多...
时间序列异常检测14篇顶会论文合集，附必备工具和数据集

时间序列异常检测14篇顶会论文合集，附必备工具和数据集

今天来聊聊一个在量化交易、网络安全检测、自动驾驶汽车和大型工业设备的日常维护等领域都有重要作用的研究主题&#xff1a;时间序列异常检测。 时间序列异常检测是一种在时间序列数据中识别和标识与预期模式、趋势或行为不符的异常点或事件的技术。鉴于它如此广泛的应用范围…
阅读更多...
与您一路同行：从代码质量到全面安全

与您一路同行：从代码质量到全面安全

作者&#xff1a;Shawn Prestridge&#xff0c;IAR资深现场应用工程师 / 美国FAE团队负责人 安全一直都是一个非常热门的话题&#xff0c;似乎每周都会听到这样的消息&#xff1a;某某公司如何被入侵&#xff0c;数百万用户的数据被泄露。 我们看到这么多的安全问题&#xff…
阅读更多...
Cesium.CustomShader颜色值显示错误

Cesium.CustomShader颜色值显示错误

官方示例&#xff1a; Cesium Sandcastle 测试过程&#xff1a; 1、修改示例&#xff0c;把customshader中的fragmentShaderText替换为如下代码 void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {//注意&#xff1a;下述颜色的b值是0.1&#x…
阅读更多...
attention中Q,K,V的理解

attention中Q,K,V的理解

第一种 1.首先定义三个线性变换矩阵&#xff0c;query&#xff0c;key&#xff0c;value&#xff1a; class BertSelfAttention(nn.Module):self.query nn.Linear(config.hidden_size, self.all_head_size) # 输入768&#xff0c; 输出768self.key nn.Linear(config.hidde…
阅读更多...
「Linux」使用C语言制作简易Shell

「Linux」使用C语言制作简易Shell

&#x1f4bb;文章目录 &#x1f4c4;前言简易shell实现shell的概念系统环境变量shell的结构定义内建命令完整代码 &#x1f4d3;总结 &#x1f4c4;前言 对于很多学习后端的同学来讲&#xff0c;学习了C语言&#xff0c;发现除了能写出那个经典的“hello world”以外&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023