Linux系统编程 day07 信号

news2024/9/22 1:23:02

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;
    // 默认标识，通常设置为0
    int        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.coloradmin.cn/o/1273217.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

对话 AI for Science 先行者，如何抓住科研范式新机遇？丨和鲸社区2023年度科研闭门会

对话 AI for Science 先行者，如何抓住科研范式新机遇？丨和鲸社区2023年度科研闭门会

2023年3月&#xff0c;科技部会同自然科学基金委启动了 AI for Science 的专项部署工作。数据驱动的科学研究长期以来面临着诸多困境&#xff0c;针对传统科研工作流中过度依赖人类专家经验与体力的局限性&#xff0c;AI for Science 旨在基于科学数据与算力支撑&#xff0c;通…
阅读更多...
香港高端人才通行证计划入围高校名单公布，如何申请？

香港高端人才通行证计划入围高校名单公布，如何申请？

香港高端人才通行证计划入围高校名单公布&#xff0c;如何申请&#xff1f; 高端人才通行证计划&#xff08;英语&#xff1a;Top Talent Pass Scheme (TTPS)&#xff09;&#xff0c;简称“高才通计划”&#xff0c;是香港为了吸引世界各地具备丰富工作经验及高学历的高端人才…
阅读更多...
力扣题:单词-11.20

力扣题:单词-11.20

力扣题-11.20 [力扣刷题攻略] Re&#xff1a;从零开始的力扣刷题生活 力扣题1&#xff1a;58. 最后一个单词的长度 解题思想&#xff1a;按空格划分&#xff0c;然后统计单词长度即可 class Solution(object):def lengthOfLastWord(self, s):""":type s: str…
阅读更多...
2021年6月23日 Go生态洞察：Stack Overflow上的Go集体

2021年6月23日 Go生态洞察：Stack Overflow上的Go集体

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
安全高效的PostgreSQL数据库迁移解决方案

安全高效的PostgreSQL数据库迁移解决方案

PostgreSQL数据库是一款高度可扩展的开源数据库系统&#xff0c;支持复杂的查询、事务完整性和多种数据类型&#xff0c;这使得它成为企业中处理大规模和多样化数据需求的理想选择。在很多企业中&#xff0c;PostgreSQL不仅处理大量的交易数据&#xff0c;还支持复杂的数据分析…
阅读更多...
java开发之基于个微群聊二次开发

java开发之基于个微群聊二次开发

请求URL&#xff1a; http://域名地址/getGroupQrCode 请求方式&#xff1a; POST 请求头Headers&#xff1a; Content-Type&#xff1a;application/jsonAuthorization&#xff1a;login接口返回 参数&#xff1a; 参数名必选类型说明wId是String登录实例标识chatRoomI…
阅读更多...
C++ 单词拆分

C++ 单词拆分

题目1&#xff1a;139 单词拆分 题目链接&#xff1a;单词拆分 对题目的理解 字符串列表wordDict作为字典&#xff0c;判断是否可以利用字典中出现的单词拼接出字符串s&#xff0c;字典中的单词可以重复使用&#xff0c;题目中字符串s的长度至少为1&#xff0c;不存在空字符…
阅读更多...
YOLOv5独家原创改进： AKConv（可改变核卷积），即插即用的卷积，效果秒杀DSConv | 2023年11月最新发表

YOLOv5独家原创改进： AKConv（可改变核卷积），即插即用的卷积，效果秒杀DSConv | 2023年11月最新发表

💡💡💡本文全网首发独家改进：可改变核卷积（AKConv），赋予卷积核任意数量的参数和任意采样形状，为网络开销和性能之间的权衡提供更丰富的选择，解决具有固定样本形状和正方形的卷积核不能很好地适应不断变化的目标的问题点，效果秒殺DSConv 1）AKConv替代标准卷积进行…
阅读更多...
Attacking Fake News Detectors via Manipulating News Social Engagement（2023 WWW）

Attacking Fake News Detectors via Manipulating News Social Engagement（2023 WWW）

Attacking Fake News Detectors via Manipulating News Social Engagement----《通过操纵新闻社交互动来攻击假新闻检测器》 摘要 在年轻一代中&#xff0c;获取新闻的主要来源之一是社交媒体。随着新闻在各种社交媒体平台上日益流行&#xff0c;虚假信息和毫无根据的言论的传…
阅读更多...
GPU逻辑管线

GPU逻辑管线

文章目录 前言一、渲染流水线二、英伟达显卡简化概念图&#xff08;GPU&#xff09;1、我们的Shader会调用英伟达提供的 API2、调用API后&#xff0c;把Shader用到的指令存储在Pushbuffer中3、然后图元分配器&#xff0c;会把 模型数据 和 Shader 指令传入GPU中4、这个SM是每个…
阅读更多...
VGN S99快捷键，说明书

VGN S99快捷键，说明书

VGN S99快捷键-说明书 按键说明灯光效果常见疑难 按键说明 切换关闭电量指示灯&#xff1a;Fn home 灯光效果 常见疑难
阅读更多...
GAN：WGAN

GAN：WGAN

论文&#xff1a;https://arxiv.org/pdf/1701.07875.pdf 发表&#xff1a;2017 WGAN 算法流程 从GAN 到 WGAN 的转变 相比于原始 GAN&#xff0c;WGAN 只需要修改以下几点&#xff0c;就能使得训练更稳定&#xff0c;生成质量更高&#xff1a; 1. 此时的判别器相当于做回归…
阅读更多...
ubuntu下QT搭建Android开发环境

ubuntu下QT搭建Android开发环境

一、前言 用QT开发android和直接使用android开发的区别 使用Qt开发Android应用和直接使用Android开发工具&#xff08;例如Android Studio&#xff09;有一些区别&#xff0c;主要体现在开发工具、语言、界面设计和性能等方面&#xff1a; 开发工具&#xff1a; Qt Creat…
阅读更多...
pycharm安装django框架详细教程（指定版本）

pycharm安装django框架详细教程（指定版本）

教程目录 前言一、确保已安装好python和pycharm工具二、利用pycharm创建纯python项目&#xff0c;同时创建虚拟环境三、通过pycharm命令行安装Django指定版本四、通过pycharm命令行创建一个Django项目五、在pycharm中进行相关配置六、利用pycharm按钮启动Django项目 前言 在实…
阅读更多...
常用API—String（操作字符串的工具类）

常用API—String（操作字符串的工具类）

一&#xff0c;创建字符串的方法 二&#xff0c;案例 public static void main(String[] args) {//1,直接创建String string "gears";System.out.println(string);//2&#xff0c;用对象创建String s1 new String("xiaoheizi");System.out.println(s1);//3…
阅读更多...
高效解决在本地打开可视化服务器端的tensorboard

高效解决在本地打开可视化服务器端的tensorboard

文章目录 问题解决方案 问题 由于连着远程服务器构建模型&#xff0c;但是想在本地可视化却做不到&#xff0c;不要想当然天真的以为CTRLC点击链接http://localhost:6006就真能在本地打开tensorboard。你电脑都没连接服务器&#xff0c;只是pycharm连上了而已 解决方案 你需要…
阅读更多...
有趣的代码——井字棋游戏的实现

有趣的代码——井字棋游戏的实现

前面我们讲解过一个猜数字游戏的实现&#xff0c;想来应该让大家感受到了属于编程的趣味性&#xff0c;并且在实现过程中应该也收获了知识。但猜数字这种简单的游戏肯定满足不了大家对于游戏的高标注、严要求&#xff0c;估计玩不了多久就会没有兴趣了&#xff0c;所以&#xf…
阅读更多...
渗透测试-环境部署

渗透测试-环境部署

环境部署 一、kali的环境部署二、DNSenum工具&#xff1a;深入挖掘目标域名的DNS信息三、安装Burpsuite四、安装根证书五、JSFinder的使用六、App、小程序、公众号提取 一、kali的环境部署 1.配置SSH 修改配置文件 vi /etc/ssh/sshd_config 找到 # PermitRootLogin prohibit…
阅读更多...
收藏！7个小众宝藏的开发者学习类网站

收藏！7个小众宝藏的开发者学习类网站

1、simplilearn 地址&#xff1a;https://www.simplilearn.com/ simplilearn是全球排名第一的在线学习网站&#xff0c;它的课程由世界知名大学、顶级企业和领先的行业机构通过实时在线课程设计和提供&#xff0c;其中包括顶级行业从业者、广受欢迎的培训师和全球领导者。 2、…
阅读更多...
java springboot通过application配置文件生成随机值并控制范围

java springboot通过application配置文件生成随机值并控制范围

我们找到 项目的 application 配置文件 这里我们还是习惯用 yml格式的 我们在配置文件中 写出 ${random.} 的时候 他就会将所有可配置的随机类型都提示出来了 有 整数 长整星 字符串 uuid 这里 我们来个模板 testcase:book:id: ${random.int}name: ${random.value}date: ${r…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023