【Linux】进程创建/终止/等待/替换

news2025/7/19 11:29:03

目录

一、子进程的创建

1、fork函数的概念

2、如何理解fork拥有两个返回值

3、fork调用失败的场景

二、进程的终止

1、main函数返回值

1.1main函数的返回值的意义

1.2将错误码转化为错误信息

1.3查看进程的退出码

2、进程退出的情况

1、进程的正常退出与异常退出

2、库函数exit

3、系统调用_exit

三、进程等待

1、进程等待的必要性

2、进程等待的方法

2.1系统调用wait

2.2系统调用waitpid

3、status值的意义

4、图解父进程等待子进程的方式

5、阻塞/非阻塞式等待

四、进程程序替换

1、进程程序替换的概念

2、进程程序替换的原理

3、exec*()系列函数的返回值

4、main函数在磁盘中被加载到内存的原理

五、写一个shell

一、子进程的创建

1、fork函数的概念

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程（子进程的PID是0），而原进程为父进程。

#include <unistd.h>
pid_t fork(void);

返回值：fork创建子进程成功后，会给父进程返回子进程的PID，给子进程返回0，失败则返回-1。

为什么要让父进程拿到子进程的PID?因为子进程变为僵尸状态后，需要父进程读取子进程的退出信息并回收资源。

操作系统将会给创建成功的子进程：

1、给子进程分配新的内存块和内核数据结构（PCB、进程地址空间、页表等，并构建对应的映射关系）；

2、将父进程的部分数据结构内容拷贝至父进程；

3、把子进程添加到系统进程列表中；

4、fork返回，调度器开始调度。

2、如何理解fork拥有两个返回值

在fork函数return之前，就已经有了父子两个进程，给父进程返回子进程的PID，给子进程返回0，失败则返回-1。

利用这个特性，我们可以用变量接收返回值，根据fork返回值不同让父子进程执行不同的代码。

#include <stdio.h>
#include <unistd.h>
int main()
{
    pid_t id=fork();
    if(id==0)
    {
        printf("子进程:pid=%d,ppid=%d | grobal_val=%d,&grobal_val=%p\n",getpid(),getppid(),grobal_val,&grobal_val);
    }
    else if(id>0)
    {
        printf("父进程:pid=%d,ppid=%d | grobal_val=%d,&grobal_val=%p\n",getpid(),getppid(),grobal_val,&grobal_val);
        sleep(1);
    }
    else 
    {
        printf("fork error\n");
        return 1;
    }
    return 0;
}

pid_t id=fork()这句代码父子进程谁先返回不确定。谁先返回，谁就在虚拟内存中写入id的值，后返回的进程由于进程的独立性将会发生写时拷贝。所以，我们可以看到父子进程的id变量的虚拟地址是一样的，但是内容却不一样。

3、fork调用失败的场景

系统中的进程数达到了最大限制。

二、进程的终止

1、main函数返回值

1.1main函数的返回值的意义

int main()
{
    return 0;
}

return 后面的值代表进程退出的时候，对应的退出码。标定进程执行的结果是否正确。

如果不关心一个进程的退出码，可以直接return 0；如果要关心进程的退出码，则要返回特定的数字以表明进程不同的错误。

1.2将错误码转化为错误信息

函数原型：

#include <string.h>
char* strerror(int errnum);

遍历打印错误码： 

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main()
{
    for(int i=0;i<150;++i)
    {
        printf("num[%d]:%s\n",i,strerror(i));
    }
    return 0;
}

可以看到不同的错误码对应的出错误信息。

1.3查看进程的退出码

echo $?

$?会记录最近一个进程在命令行中执行完毕时的退出码，即main函数的返回值。

2、进程退出的情况

1、进程的正常退出与异常退出

正常终止（父进程获取退出码）：

1、程序执行完毕，main函数返回0

2、程序执行完毕，但是返回值不为0，例如调用exit()和_exit()或return !0。

异常终止（父进程获取退出信号）：

ctrl+c或除0错误等导致程序被信号终止。

2、库函数exit

函数原型：

#include <stdlib.h>
void exit(int status);

库函数exit在进程退出后，会主动刷新缓冲区。

3、系统调用_exit

函数原型：

#include <unistd.h>
void _exit(int status);

系统调用_exit在进程退出后，并不会主动刷新缓冲区。

三、进程等待

1、进程等待的必要性

子进程退出后会进入僵尸状态，父进程通过进程等待的方式，获取子进程的退出信息，回收子进程资源，让子进程结束僵尸状态。当然，在子进程没有退出时，父进程只能阻塞等待子进程变成僵尸状态。

2、进程等待的方法

头文件：

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

2.1系统调用wait

函数原型：

pid_t wait(int* status);

返回值：等待成功被等待进程的pid，失败返回-1。

参数：status输出型参数，获取子进程退出码和退出状态,不关心则可以设置成为NULL。

通过wait让父进程获取子进程的PID。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t id=fork();
    if(id==0)
    {
        //子进程
        int cnt=3;
        while(cnt--)
        {
            printf("子进程：%d  父进程：%d  %d\n",getpid(),getppid(),cnt);
            sleep(1);
        }
        exit(0);//子进程退出
    }
    sleep(5);
    pid_t ret =wait(NULL);
    if(id>0) 
    {
        //父进程
        printf("等待成功:%d\n",ret);
    }
    
    return 0;
}

2.2系统调用waitpid

函数原型：

pid_t waitpid(pid_t pid,int* status,int options);

返回值：当正常返回的时候waitpid返回收集到的子进程的进程PID；如果设置了选项WNOHANG,而调用waitpid发现没有已退出的子进程可收集,则返回0；如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

参数：

PID：

PID=-1,等待任一个子进程。与wait等效。PID>0，等待进程为PID的子进程。

status:

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）

WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

//WIFEXITED和WEXITSTATUS是两个宏
if(WIFEXITED(status))//判断子进程是否正常退出（判断退出信号）
{
	printf("exit code:%d\n",WEXITSTATUS(status));//判断子进程运行结果是否正常（判断退出码）
}
else{
    //something to do 
}

options:

WNOHANG: 若PID指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的PID。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t id=fork();
    if(id==0)
    {
        //子进程
        int cnt=3;
        while(cnt--)
        {
            printf("子进程：%d  父进程：%d  %d\n",getpid(),getppid(),cnt);
            sleep(1);
        }
        exit(10);//子进程退出
    }
    int status=0;
    pid_t ret =waitpid(id,&status,0);
    if(id>0) 
    {
        //父进程
        printf("等待成功:%d,ret=%d\n",ret,status);
    }
    sleep(5);
    return 0;
}

通过修改子进程的退出码，可以打印出不同的status值，因为status用于存储子进程的退出码和退出信号。

3、status值的意义

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。

如果传递NULL，表示不关心子进程的退出状态信息。

否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

status不能简单的当作整型，可以当作位图来看待。（只研究status低16比特位）：

在进程退出时，终止信号是评判一个进程是否正常退出；退出状态是评判一个进程运行的结果是否正确。

1、使用kill -l来查看进程终止的信号。

2、根据退出码确定进程的退出状态。

以下代码手动调用waitpid模拟父进程等待子进程的过程：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t id=fork();
    if(id==0)
    {
        //子进程
        int cnt=3;
        while(cnt--)
        {
            printf("子进程：%d  父进程：%d  %d\n",getpid(),getppid(),cnt);
            sleep(1);
        }
        exit(10);//子进程退出
    }
    int status=0;
    pid_t ret =waitpid(id,&status,0);
    if(id>0) 
    {
        //父进程
        printf("等待成功,返回值子进程的PID:%d,终止信号：%d,子进程退出码：%d\n",ret,(status&0X7F),((status>>8)&0XFF));
    }
    sleep(5);
    return 0;
}

4、图解父进程等待子进程的方式

1、调用wait/waitpid后，父进程只能阻塞等待子进程变成僵尸状态。

2、子进程退出后变成僵尸状态，task_struct中的代码和数据会被释放掉，并把自己的退出信号、退出码写入到自己的task_struct中；

3、wait/waitpid是系统调用，操作系统有资格也有能力去读取子进程的task_struct。

4、父进程通过进程等待的方式，获取子进程的退出信息，回收子进程资源，让子进程结束僵尸状态。

5、阻塞/非阻塞式等待

阻塞式等待：当父进程调用wait/waitpid（第三个参数为0）等待子进程，如果子进程暂未退出，父进程会被阻塞，暂停运行，如果父进程刚好没事干，可以选择使用阻塞等待。

非阻塞式等待：当父进程调用waitpid（第三个参数为WNOHANG）等待子进程，如果父进程检测到子进程未退出，父进程并不会原地等待，而是继续执行自己的代码。如果使用while循环，便能达到轮询的效果。

非阻塞式等待不会占用父进程的精力，父进程可以在轮询的过程中做其他事情：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>

#define NUM 5
typedef void (*func_t)(); //函数指针
func_t handlerTask[NUM];//函数指针数组

//任务
void task1()
{
    printf("handler task1\n");
}
void task2()
{
    printf("handler task2\n");
}
void task3()
{
    printf("handler task3\n");
}

void loadTask()
{
    memset(handlerTask, 0, sizeof(handlerTask));//将函数指针数组初始化为0
    handlerTask[0] = task1;//函数指针数组handlerTask[0]存放task1的地址
    handlerTask[1] = task2;
    handlerTask[2] = task3;
}
int main()
{
    pid_t id = fork();
    assert(id != -1);
    if(id == 0)
    {
        //child
        int cnt = 10;
        while(cnt)
        {
            printf("child running, pid: %d, ppid: %d, cnt: %d\n", getpid(), getppid(), cnt--);
            sleep(1);
        }
        exit(10);
    }
    loadTask();//加载任务
    // parent
    int status = 0;
    while(1)//父进程对子进程状态轮询
    {
        pid_t ret = waitpid(id, &status, WNOHANG);//第三个参数为0表示阻塞式等待，为WNOHANG表示非阻塞式等待
        if(ret == 0)//等于0代表没有被等待的进程暂未退出
        {
            printf("wait done, but child is running...., parent running other things\n");
            for(int i = 0; handlerTask[i] != NULL; i++)//遍历到NULL，即0停止
            {
                handlerTask[i](); //采用回调的方式，执行我们想让父进程在空闲的时候做的事情
            }
        }
        else if(ret > 0)//waitpid调用成功，并且子进程退出，返回值为被等待子进程的pid
        {
            printf("wait success, exit code: %d, sig: %d\n", (status>>8)&0xFF, status & 0x7F);
            break;
        }
        else//等于-1表示等待失败，waitpid中的第一个参数值传错会导致调用失败
        {
            printf("waitpid call failed\n");
            break;
        }
        sleep(1);
    }
    return 0;
}

四、进程程序替换

1、进程程序替换的概念

将磁盘中指定的程序加载到内存中，让指定的进程进行执行。不论是何种后端语言写的程序，exec*函数都可以调用。

替换函数：

#include <unistd.h>`
//execve的封装
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);
//系统调用
int execve(const char *filename, char *const argv[],char *const envp[]);

l(list) : 表示参数采用列表 ；

p(path) : 带p，不用传入地址，传入可执行程序的名字即可，它会自动去环境变量PATH中寻找该可执行程序的地址；

v(vector) :执行参数放入数组中，统一传递；

e(env) : 可以传入自己写的环境变量。

1、通过execl函数调用ls命令：

#include <stdio.h>
#include <unistd.h>
int main()
{
    printf("process is running·····\n");
    execl("/usr/bin/ls"/*要执行的程序*/,"ls","--color=auto","-a","-l",NULL/*如何执行*/);//一定要用NULL结尾
    printf("process is down·····\n");//这句话并不会被打印，因为后续代码和数据已经被execl函数替换了
    return 0;
}

如果调用execl函数，参数传错导致函数调用失败，后续代码将不会被覆盖。

2、通过execle函数调用外部程序并使用自定义环境变量：

#include <stdio.h>
#include <unistd.h>
int main()
{
    printf("process is running··\n");
    //使用自定义的环境变量
    //char* const _env[]={(char*)"MYENV=12345",NULL};
    //execle("./mybin","mybin",NULL,_env);
    
    //使用系统的环境变量
    //extern char** environ;
    //execle("./mybin","mybin",NULL,environ);//系统环境变量不传，进程也能获取
    
    //使用putenv将自己的环境变量导入到environ指向的环境变量表中
    extern char** environ;
    char* const _env[]={(char*)"MYENV=12345",NULL};
    putenv((char*)"MYENV=654321");
    execle("./mybin","mybin",NULL,environ);
    printf("process is running··\n");
    return 0;
}

2、进程程序替换的原理

程序替换的本质：用磁盘指定位置上的程序的代码和数据，覆盖进程自身的代码和数据，达到让进程执行指定程序的目的。

3、exec*()系列函数的返回值

exec()函数仅在发生错误时返回。返回值为-1，设置errno以指示错误。

可以看到exec*系列函数调用成功后并没有返回值，因为exec*一旦被调用成功，后续代码将被覆盖，根本没机会用到返回值。

4、main函数在磁盘中被加载到内存的原理

五、写一个shell

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>
#include <string.h>
#define NUM 100
#define OPT_NUM 20
char LineCommend[NUM];
char* myargv[OPT_NUM];//指针数组，用于记录切割出来的字符串
int  lastCode = 0;
int  lastSig = 0;
int main()
{   
    while(1)
    {
        printf("用户名@主机名 当前路径:");
        fflush(stdout);
        //获取输入内容
        char* s=fgets(LineCommend,sizeof(LineCommend),stdin);
        assert(s!=NULL);
        //清除最后一个\n
        LineCommend[strlen(LineCommend)-1]=0;
        //字符串切割
        myargv[0]=strtok(s," ");
        int i=1;
        if(myargv[0]!=NULL&&strcmp(myargv[0],"ls")==0)//判断myargv[0]是否切割正常，穷举指令，为指令添加选项
        {
            myargv[i++]=(char*)"--color=auto";
        }
        while(myargv[i++]=strtok(NULL," "));//如果切割完毕，strtok会返回NULL，刚好myargv[end]需要等于NULL
        if(myargv[0]!=NULL&&strcmp(myargv[0],"cd")==0)//解决cd命令返回的是子进程的上级目录问题
        {
            if(myargv[1]!=NULL)
            {
               chdir(myargv[1]);//使用chdir()改变父进程的当前路径
               continue;//如果改变路径，就continue跳出本轮循环，后续子进程可以不用创建
            }
        }
        if(myargv[0] != NULL && myargv[1] != NULL && strcmp(myargv[0], "echo") == 0)
        {
            if(strcmp(myargv[1], "$?") == 0)
            {
                printf("%d, %d\n", lastCode, lastSig);
            }
            else
            {
                printf("%s\n", myargv[1]);
            }
            continue;
        }
        //测试是否成功
#ifdef DEBUG 
        for(i=0;myargv[i];++i)
        {
            printf("myargv[%d]:%s\n",i,myargv[i]);
        }
#endif
        //执行命令
        pid_t id=fork();//创建子进程，让子进程去执行被切割出来的指令
        assert(id!=-1);
        if(id==0)
        {
            execvp(myargv[0],myargv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        (void)ret;
        lastCode = ((status>>8) & 0xFF);
        lastSig = (status & 0x7F);
    }
    return 0;
}

运行该程序，可以实现shell的效果，如果33行-40行逻辑如果不写，使用cd ..指令回到上级目录时，发现我们在原地TP。

原因：因为这个"模拟shell"程序会使用fork()创建子进程执行指令，当使用cd ..时，回到的是子进程的上级目录，不会改变父进程的当前工作目录。可以额外判断一下cd命令，如果是cd命令，使用chdir改变父进程的工作目录，continue跳出本轮循环。（无需创建后续子进程）

像这种不需要子进程来执行，而是让shell来执行的命令叫做内建/内置命令。这也解释了为什么echo能打印本地环境变量，因为echo也是一个内建命令，由shell执行，shell当然能打印本地环境变量。

查看进程当前目录：

可以使用chdir()更改进程的当前目录。

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

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

相关文章

Principal branch

Principal branch

In mathematics, a principal branch is a function which selects one branch (“slice”) of a multi-valued function. Most often, this applies to functions defined on the complex plane. Contents1 Examples1.1 Trigonometric inverses1.2 Exponentiation to fraction…
阅读更多...
255-261BFC,媒体的类型，媒体的特性，浏览器前缀，媒体查询，逻辑操作符，

255-261BFC,媒体的类型，媒体的特性，浏览器前缀，媒体查询，逻辑操作符，

◼ 有时候可能会看到有些CSS属性名前面带有：-o-、-xv-、-ms-、mso-、-moz-、-webkit- ◼ 官方文档专业术语叫做：vendor-specific extensions（供应商特定扩展） ◼ 为什么需要浏览器前缀了？  CSS属性刚开始并没有成为标准，浏览器为了防止后续会修改名字给新的属性添加了浏…
阅读更多...
树莓派学习笔记（一）

树莓派学习笔记（一）

树莓派学习笔记 笔记来自B站UP主【树小悉】的树莓派系列视频的听课笔记&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;适合新手入门&#xff0c;强烈推荐&#xff01;&#xff01;&#xff01; 关机命令 sudo poweroff 关闭电源sodo shutdown -h now 立刻关机sudp shut…
阅读更多...
二、进程管理（四）经典同步互斥问题

二、进程管理（四）经典同步互斥问题

目录 4.1生产者-消费者问题 4.1.1单类生产者-单类消费者问题 4.1.2多类生产者-多类消费者问题 4.1.3吸烟者问题 4.2读者-写者问题 4.3哲学家进餐问题 分析进程同步和互斥问题的三步&#xff1a; 关系分析&#xff1a;分析问题中的同步&#xff08;前驱关系&#xff09;、…
阅读更多...
端口渗透篇：Java RMI 远程代码执行漏洞

端口渗透篇：Java RMI 远程代码执行漏洞

转载https://cloud.tencent.com/developer/article/2149191 前言持续更新&#xff1a;整理下渗透测试工作中发现过的漏洞&#xff08;包含漏洞描述、漏洞等级、漏洞验证、修复建议&#xff09;&#xff0c;这里不深究漏洞产生的各种后利用或者绕过方式&#xff0c;漏洞验证过程…
阅读更多...
【Python游戏】Python各大游戏合集（5）：塔防游戏、飞机大战、连连看、打地鼠、记忆翻牌 | 附带源码

【Python游戏】Python各大游戏合集（5）：塔防游戏、飞机大战、连连看、打地鼠、记忆翻牌 | 附带源码

相关文件 关注小编&#xff0c;私信小编领取哟&#xff01; 当然别忘了一件三连哟~~ 公众号&#xff1a;Python日志 可以关注小编公众号&#xff0c;会不定时的发布一下Python小技巧&#xff0c;还有很多资源可以免费领取哟&#xff01;&#xff01; 源码领取&#xff1a;加P…
阅读更多...
【高速数字化仪应用案例系列】虹科数字化仪在通信领域的应用

【高速数字化仪应用案例系列】虹科数字化仪在通信领域的应用

通信应用 随着国际社会要求以越来越快的速度传输更多信息&#xff0c;电子通信也在不断发展。模拟和数字技术用于无线、光纤和有线网络系统提供的点对点和广播通信。为了开发和维护这些系统&#xff0c;工程师需要能够测试和鉴定接收和传输的信号。需要减少信号损失或衰减&…
阅读更多...
SpringBoot SpringBoot 原理篇 1 自动配置 1.2 bean 的加载方式【二】

SpringBoot SpringBoot 原理篇 1 自动配置 1.2 bean 的加载方式【二】

SpringBoot 【黑马程序员SpringBoot2全套视频教程&#xff0c;springboot零基础到项目实战&#xff08;spring boot2完整版&#xff09;】 SpringBoot 原理篇 文章目录SpringBootSpringBoot 原理篇1 自动配置1.2 bean 的加载方式【二】1.2.1 第二种方式1 自动配置 1.2 bean …
阅读更多...
idea 项目代码打包为jar包详解

idea 项目代码打包为jar包详解

目录前言一、将所有依赖和模块代码打包为一个jar二、只将模块代码打包为一个jar前言 假设我有如下简单 maven 项目 点击 File > Project Structure > Artifacts > 点击加号 > 选择JAR > 选择From modules with dependencies 一、将所有依赖和模块代码打包为一…
阅读更多...
【树莓派不吃灰】命令篇⑨ 记录学习文件系统

【树莓派不吃灰】命令篇⑨ 记录学习文件系统

目录1. 外部存储设备1.1 分区挂载1.2 查看磁盘信息&#xff08;包括未挂载磁盘&#xff09;1.2.1 mmcblk0p01.2.2 sda1&#xff08;额外了解&#xff09;1.3 查看UUID1.4 查看文件系统挂载情况2. 文件系统2.1 索引式文件系统2.1.1 EXT2 文件系统&#xff08;了解&#xff09;2.…
阅读更多...
Android 序列化框架 Gson 原理分析，可以优化吗？

Android 序列化框架 Gson 原理分析，可以优化吗？

本文已收录到 AndroidFamily&#xff0c;技术和职场问题&#xff0c;请关注公众号 [彭旭锐] 提问。 前言 大家好&#xff0c;我是小彭。 Gson 是 Google 推出的 Java Json 解析库&#xff0c;具有接入成本低、使用便捷、功能扩展性良好等优点&#xff0c;想必大家都很熟悉了。…
阅读更多...
ES6 入门教程 25 Module 的加载实现 25.4 循环加载

ES6 入门教程 25 Module 的加载实现 25.4 循环加载

ES6 入门教程 ECMAScript 6 入门 作者&#xff1a;阮一峰 本文仅用于学习记录&#xff0c;不存在任何商业用途&#xff0c;如侵删 文章目录ES6 入门教程25 Module 的加载实现25.4 循环加载25.4.1 CommonJS 模块的加载原理25.4.2 CommonJS 模块的循环加载25.4.3 ES6 模块的循环加…
阅读更多...
MobPush Android 快速集成

MobPush Android 快速集成

开发工具&#xff1a;Android Studio 集成方式&#xff1a;Gradle在线集成 安卓版本支持&#xff1a;minSdkVersion 19 集成准备 注册账号 使用PushSDK之前&#xff0c;需要先在MobTech官网注册开发者账号&#xff0c;并获取MobTech提供的AppKey和AppSecret&#xff0c;详情可…
阅读更多...
Gitblit自建仓库及多人使用

Gitblit自建仓库及多人使用

上稿已完成了Git Server部署了&#xff0c;现在开始创建仓库及笔者常用的IDE使用 第一步&#xff1a;SSH密钥生成&#xff0c;并保存到GitBlit 正常Git都会用到的server SSH Keys&#xff0c;这里自建同样少不了 【问题直接在CMD输入命令&#xff0c;直接切菜&#xff0c;笔…
阅读更多...
ShardingSphere （一）

ShardingSphere （一）

ShardingSphere &#xff08;一&#xff09; ShardingSphere-JDBC 与 SpringBoot 集成 ShardingSphere-JDBC 定位为轻量级 Java 框架&#xff0c;在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库&#xff0c;以 jar 包形式提供服务&#xff0c;无需额外部署和依赖…
阅读更多...
气人|这种通过率调优技巧居然这么晚才让我知道

气人|这种通过率调优技巧居然这么晚才让我知道

量化风控审核过程中的通过率在贷前策略中是一大重要的内容&#xff0c;另外一个是逾期率。二者之间的因果关系就是通过率高低变化决定了逾期率风险的走势&#xff0c;通过率决定了逾期率的结果&#xff0c;而逾期率又对通过率起到了一个制衡的作用。 很多的风险管理人员常常会遇…
阅读更多...
前端实现克里金插值分析(一)

前端实现克里金插值分析(一)

作者:yangjunlin 最近不少小伙伴问我怎么搞前端插值分析&#xff0c;我在github上查找了一些资料&#xff0c;目前最常用的方式是webgis框架idw&#xff08;反距离权重算法&#xff09;d3-contour的方式实现&#xff0c;这种方式是比较简单同时基本能满足一般的气象分析&#x…
阅读更多...
Netty入门学习

Netty入门学习

同步&#xff1a;当调用方法的线程和接收结果的线程是同一个&#xff0c;这意味着阻塞&#xff0c;那么是同步。 异步&#xff1a;当调用方法的线程和处理结果的线程不是同一个&#xff0c;这意味着不是阻塞&#xff0c;是异步。 下图是一个简单的Netty的客户端和服务器端 【…
阅读更多...
论文阅读笔记 | 三维目标检测——VoxelNet算法

论文阅读笔记 | 三维目标检测——VoxelNet算法

如有错误&#xff0c;恳请指出。 文章目录1.背景2. 网络结构2.1 体素特征表示2.2 卷积特征提取2.3 RPN网络3. 实验结果paper&#xff1a;《VoxelNet: End-to-End Learning for Point Cloud Based 3D Object Detection》 1.背景 以往的3d检测器都难免利用了手工设计特征(hand-…
阅读更多...
ES6 入门教程 29 ArrayBuffer 29.1 ArrayBuffer 对象

ES6 入门教程 29 ArrayBuffer 29.1 ArrayBuffer 对象

ES6 入门教程 ECMAScript 6 入门 作者&#xff1a;阮一峰 本文仅用于学习记录&#xff0c;不存在任何商业用途&#xff0c;如侵删 文章目录ES6 入门教程29 ArrayBuffer29.1 ArrayBuffer 对象29.1.1 概述29.1.2 ArrayBuffer.prototype.byteLength29.1.3 ArrayBuffer.prototype.s…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023