当前位置： 首页 > news >正文

一、进程间通信（IPC）


1.1    进程间通信的引入


1>    对于多个线程之间通信，我们可以使用临界资源来完成，通过一个线程任务对临界资源进行修改，另一个线程也可以使用已经修改过的临界资源，但是要注意使用同步互斥机制完成对临界资源的保护
2>    多个进程之间能否使用全局变量来进行进程间通信？
答：不能，多个进程之间的用户空间是相互独立的，每个进程的全局变量是各个进程独立拥有的，更改一个进程的全局变量，另一个进程不会受到影响，故而不能使用全局变量来完成通信
3>    有同学说：使用文件来完成进程间通信？
答：可行，但是要求写进程先完成向文件中写入数据，然后读进程才能读取数据，必须要加入进程的同步操作
4>    多个进程之间内核空间是共享的，我们可以通过将数据放入到内核空间，来完成两个进程之间信息的交流

5>    进程间通信方式：

1、内核提供的原始通信方式
        无名管道
        有名管道
        信号
2、system V提供三种
        消息队列
        共享内存
        信号量集
 


1.2    无名管道


1>    顾名思义就是没有名字的管道文件，所以只能适用于亲缘进程间的通信
2>    原理：通过内核，在内存中创建出一个管道文件，存放在内存空间，并不在文件系统中真实存在。当打开该文件时，会返回该文件的两个文件描述符，分别对应读端和写端。可以通过读端从管道中读取数据，从写端向管道中写入数据。当该文件的读写两端全部被关闭后，该管道文件会在内存中消失
3>    注意：由于打开管道时返回的是文件描述符，所以，对该文件的操作，只能使用文件IO
对于存入管道中的数据的读取是一次性的，当数据读取结束后，数据就不存在于管道文件中了
4>    无名管道的API接口函数

       #include <unistd.h>
 
       int pipe(int pipefd[2]);
       功能：在通过内核在内存中创建一个无名管道，并通过参数将该管道文件的两个文件描述符返回
       参数：接收文件描述符的数组，pipefd[0]表示管道文件的读端，pipefd[1]表示管道的写端
       返回值：成功返回0，失败返回-1并置位错误码
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
 
    //创建用于通信的管道文件，并返回该文件对应的文件描述符
    int pipefd[2] ;
    if(pipe(pipefd)==-1)
    {
        perror("pipe error");
        return -1;
    }
 
 
    //创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error");
        return -1;
    }else if(pid  == 0)
    {
        //子进程
        close(pipefd[1]);          //关闭写端
    
        //接受父进程发来的消息
        char rbuf[128] = "";
 
        while(1)
        {
            bzero(rbuf, sizeof(rbuf));
 
            //从管道中读取数据
            read(pipefd[0], rbuf, sizeof(rbuf));
 
            if(strcmp(rbuf, "quit")==0)
            {
                break;
            }
 
            //输出数据
            printf("收到父进程的来信：%s\n", rbuf);
        }
 
        //关闭读段
        close(pipefd[0]);
 
 
        //退出进程
        exit(EXIT_SUCCESS);
    }
 
    //父进程
    char sbuf[128] = "";
     //关闭读端
    close(pipefd[0]);
    while(1)
    {        
 
        usleep(10);
        printf("父进程中输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);          //从终端获取字符串
        sbuf[strlen(sbuf)-1] = 0;
 
        //发送给子进程,将数据通过写端写入管道 pipefd[1]
        write(pipefd[1], sbuf, strlen(sbuf));
 
        //判断终端获取的数据
        if(strcmp(sbuf, "quit") == 0)
        {
            break;
        }
 
        //关闭写端
        close(pipefd[1]);
    }
 
    
 
    //回收子进程资源
    wait(NULL);
 
    return 0;
}
 
5>    总结管道通信的特点

1、管道通信是半双工的通信方式
    单工：任意时刻只能A向B发送消息，B不能向A发送消息
    半双工：同一时刻，只能A向B发送消息或者B向A发消息
    全双工：任意时刻，AB可以互相发送消息
2、无名管道只适用于亲缘进程间通信
3、无名管道也能完成自己跟自己的通信
4、无名管道文件的大小：64KB
6>    管道的读写特点（笔试面试）

1、当管道读端存在时，写管道有多少写多少，直到写满64K为止
2、当管道读端不存在时，写管道写入数据时，会出现管道破裂，此时内核空间会向用户空间发送一个SIGPIPE信号
3、当写端存在时，读管道有多少读多少，没有数据会在read处阻塞
4、当写端不存在时，读管道有多少读多少，没有数据也不会在read处阻塞
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //创建一个五名管道
    int fds[2];
 
    if(pipe(fds) == -1)
    {
        perror("pipe error");
        return -1;
    }
 
    //向管道中写入数据
    char buf = 'A';
    int count = 0;       //记录写入的大小
    while(1)
    {
        write(fds[1], &buf, 1);
        count ++;
        printf("count = %d\n", count);
        //关闭读端
        close(fds[0]);
    }
 
 
    while(1);
 
    return 0;
}
 
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
 
    //创建用于通信的管道文件，并返回该文件对应的文件描述符
    int pipefd[2] ;
    if(pipe(pipefd)==-1)
    {
        perror("pipe error");
        return -1;
    }
 
 
    //创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error");
        return -1;
    }else if(pid  == 0)
    {
        //子进程
        close(pipefd[1]);          //关闭写端
    
        //接受父进程发来的消息
        char rbuf[128] = "";
 
        while(1)
        {
            bzero(rbuf, sizeof(rbuf));
 
            //从管道中读取数据
            read(pipefd[0], rbuf, sizeof(rbuf));
 
            if(strcmp(rbuf, "quit")==0)
            {
                break;
            }
 
            //输出数据
            printf("收到父进程的来信：%s\n", rbuf);
        }
 
        //关闭读段
        close(pipefd[0]);
 
 
        //退出进程
        exit(EXIT_SUCCESS);
    }
 
    //父进程
    char sbuf[128] = "";
    //关闭读端
    close(pipefd[0]);
    while(1)
    {
 
 
        usleep(10);
        printf("父进程中输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);          //从终端获取字符串
        sbuf[strlen(sbuf)-1] = 0;
 
        //发送给子进程,将数据通过写端写入管道 pipefd[1]
        write(pipefd[1], sbuf, strlen(sbuf));
 
        //判断终端获取的数据
        if(strcmp(sbuf, "quit") == 0)
        {
            break;
        }
 
        //关闭写端
        close(pipefd[1]);
 
 
    }
 
    //关闭写端
    close(pipefd[1]);
 
    //回收子进程资源
    wait(NULL);
 
    return 0;
}
 
 


1.3    有名管道


1>    顾名思义就是有名字的管道文件，会在文件系统中创建一个有名字的管道文件
2>    可以用于亲缘进程间的通信，也可以用于非亲缘进程间的通信
3>    有名管道的API函数

       #include <sys/types.h>
       #include <sys/stat.h>
 
       int mkfifo(const char *pathname, mode_t mode);
    功能：在文件系统中创建一个有名管道，但是并没有打开该文件
    参数1：有名管道的名称
    参数2：管道文件的权限
    返回值：成功返回0，失败返回-1并置位错误码
create.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //创建一个有名管道文件
    if(mkfifo("./linux", 0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
 
    getchar();
 
    system("rm linux");
    
    return 0;
}
 
snd.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //以写的形式打开管道文件
    int wfd = open("./linux", O_WRONLY);
    if(wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
 
    //发送数据
    char wbuf[128] = "";
    while(1)
    {
        printf("请输入>>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = 0;
 
        //将数据发送给到管道中
        write(wfd, wbuf, strlen(wbuf));
 
        //判断数据
        if(strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }
 
    //关闭文件描述符
    close(wfd);
 
    
    return 0;
}
 
recv.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //以读的形式打开文件
    int rfd = open("./linux", O_RDONLY);
    if(rfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件读端打开\n");
 
    //定义接受容器
    char rbuf[128] = "";
    while(1)
    {
        bzero(rbuf, sizeof(rbuf));
        //读取数据
        read(rfd, rbuf, sizeof(rbuf));
        if(strcmp(rbuf, "quit") == 0)
        {
            break;
        }
        printf("收到消息为：%s\n", rbuf);
    }
 
    //关闭文件描述符
    close(rfd);
    
    return 0;
}
 
 


1.4    信号通信


1>    信号通信原理图：两个异步通信的进程之间，通过发送相关信号，完成任务间的通信

2>    信号是linux中软件模拟硬件的“中断”的一种方式。信号是软件部分的名词，中断是硬件部分的名词
3>    能够发送的信号可以通过指令：kill -l进行查看

 1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL     5) SIGTRAP
 6) SIGABRT     7) SIGBUS     8) SIGFPE     9) SIGKILL    10) SIGUSR1
11) SIGSEGV    12) SIGUSR2    13) SIGPIPE    14) SIGALRM    15) SIGTERM
16) SIGSTKFLT    17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ
26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO    30) SIGPWR
31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3
38) SIGRTMIN+4    39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12    47) SIGRTMIN+13
48) SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14    51) SIGRTMAX-13    52) SIGRTMAX-12
53) SIGRTMAX-11    54) SIGRTMAX-10    55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7
58) SIGRTMAX-6    59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
63) SIGRTMAX-1    64) SIGRTMAX    
4>    对于信号的处理方式有三种：默认、捕获、忽略
有两个信号既不能被捕获，也不能被忽略：SIGKILL、SIGSTOP
5>    上面的信号触发条件以及默认处理方式可以通过指令 man 7 signal进行查看

       Signal     Value     Action   Comment
       ──────────────────────────────────────────────────────────────────────
       SIGHUP        1       Term    Hangup detected on controlling terminal
                                     or death of controlling process
       SIGINT        2       Term    Interrupt from keyboard
       SIGQUIT       3       Core    Quit from keyboard
       SIGILL        4       Core    Illegal Instruction
       SIGABRT       6       Core    Abort signal from abort(3)
       SIGFPE        8       Core    Floating-point exception
       SIGKILL       9       Term    Kill signal
       SIGSEGV      11       Core    Invalid memory reference
       SIGPIPE      13       Term    Broken pipe: write to pipe with no
                                     readers; see pipe(7)
       SIGALRM      14       Term    Timer signal from alarm(2)
       SIGTERM      15       Term    Termination signal
       SIGUSR1   30,10,16    Term    User-defined signal 1
       SIGUSR2   31,12,17    Term    User-defined signal 2
       SIGCHLD   20,17,18    Ign     Child stopped or terminated
       SIGCONT   19,18,25    Cont    Continue if stopped
       SIGSTOP   17,19,23    Stop    Stop process
       SIGTSTP   18,20,24    Stop    Stop typed at terminal
       SIGTTIN   21,21,26    Stop    Terminal input for background process
       SIGTTOU   22,22,27    Stop    Terminal output for background process
 
6>    信号的发送者可以是内核、其他进程、用户自己
7>    将信号与信号处理方式连接函数

       #include <signal.h>
 
       typedef void (*sighandler_t)(int);
 
       sighandler_t signal(int signum, sighandler_t handler);
       功能：将信号与信号处理函数绑定到一起
       参数1：要绑定的信号
       参数2：信号处理函数
               SIG_IGN：表示忽略信号
               SIG_DFL：表示默认处理
               填自定义函数的入口地址
        返回值：成功返回处理方式的起始地址，失败返回 SIG_ERR
 
 

#include<myhead.h>
//自定义处理信号的函数
void handler(int signo)
{
    //判断传过来的信号是哪个
    if(signo == SIGINT)
    {
        printf("当前进程收到了ctrl + c，但是就是关不掉\n");
    }
 
    //判断是否为SIGKILL到位
    if(signo == SIGKILL)
    {
        printf("捕获了SIGKILL\n");
    }
    
}
 
 
/**************************主程序*******************/
int main(int argc, const char *argv[])
{
 
    //将2号信号与对应的信号处理函数进行绑定
    /*尝试忽略2号信号
    if(signal(2, SIG_IGN) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
    */
 
    //尝试捕获2号信号
    if(signal(2, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
 
    /*尝试忽略SIGKILL信号：报错，参数不合法
        if(signal(SIGKILL, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }*/
 
    /*尝试捕获SIGKILL信号：报错，参数不合法
        if(signal(SIGKILL, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
    */
 
    /*尝试默认处理:报错，参数不合法
    if(signal(SIGKILL, SIG_DFL) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }*/
 
 
    while(1)
    {
        printf("啦啦啦啦，我是卖报的小行家\n");
        sleep(1);
    }
    
 
    return 0;
}
 
 


 
1.5    特殊的信号处理


1>    SIGCHLD信号：以非阻塞的形式回收僵尸进程

#include<myhead.h>
 
//自定义信号处理函数
void handler(int signo)
{
    if(signo == SIGCHLD)
    {
        while(1)
        {
            //判断是否将僵尸进程全部回收了
            if(waitpid(-1, NULL, WNOHANG) == 0)
            {
                break;
            }
        }
    }
}
 
/******************主程序**********************/
int main(int argc, const char *argv[])
{
    //将SIGCHLD信号与信号处理函数绑定到一起
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
 
 
    for(int i=0; i<10; i++)
    {
        if(fork() == 0)
        {
            exit(EXIT_SUCCESS);
        }
    
    }
 
    while(1);
 
    /*
    for(;;)
    {
        printf("我是小妖怪，逍遥游自在\n");
        sleep(1);
    }*/
 
    return 0;
}
 
2>    SIGALRM：定时器信号
程序允许启动一个定时器，当所定的时间到位后，会发送一个SIGALRM信号，我们可以将该信号绑定到对应的信号处理函数中，从而导致，给定时间后，处理自定义函数。该信号需要使用一个函数来发送超时信号：alarm闹钟函数


       #include <unistd.h>
 
       unsigned alarm(unsigned seconds);
    功能：给进程设置一个定时器，以秒为单位，当定时器到位后，后向该进程发送一个SIGALRM的信号
    参数：秒数，如果参数设置成0，表示删除定时器
    返回值：>0:表示返回的上一个定时器剩余的秒数，并且重置上一个定时器
            0：表示之前没有设置定时器
 

#include<myhead.h>
 
//定义信号处理函数
void handler(int signo)
{
    if(signo == SIGALRM)
    {
        printf("阎王叫你三更死，怎可留人到五更\n");
        sleep(2);
        exit(EXIT_SUCCESS);
    }
}
 
 
/********************主程序******************/
int main(int argc, const char *argv[])
{
 
    //将SIGALRM信号与信号处理函数绑定
    if(signal(SIGALRM, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
 
 
    printf("%d\n", alarm(10));          //0
 
    sleep(5);
 
 
    printf("%d\n", alarm(10));          //5
 
 
    int count = 0;
    while(1)
    {
        printf("能活一秒是一秒\n");
        sleep(1);
        /*
        count++;
        if(count == 3)
        {
            alarm(0);           //删除定时器
        }
        */
    }
 
    return 0;
}
 
使用SIGALRM模拟斗地主出牌

#include<myhead.h>
 
//定义信号处理函数
void handler(int signo)
{
    if(signo == SIGALRM)
    {
        printf("系统已经自动帮您出了一张牌\n");
        alarm(5);
    }
}
 
 
/*******************主程序**********************/
int main(int argc, const char *argv[])
{
 
    //将信号与信号处理函数绑定
    if(signal(SIGALRM, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
 
 
    char ch;        //要出的牌
 
    while(1)
    {
        //启动一个定时器
        alarm(5);
 
        printf("请出牌>>");
        scanf("%c", &ch);
        getchar();
 
        printf("您出的牌为：%c\n", ch);
    }
 
    return 0;
}
 
 
 
 
 
 
 
 
 
 
 
 



1>    使用有名管道实现，一个进程用于给另一个进程发消息，另一个进程收到消息后，展示到终端上，并且将消息保存到文件上一份

xs.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //创建一个有名管道文件
    if(mkfifo("./linux", 0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
 
    getchar();
     //删除管道文件
    system("rm linux");
    return 0;
}
 cb.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //以写的形式打开管道文件
    int wfd = open("./linux", O_WRONLY);
    if(wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
 
    //发送数据
    char wbuf[128] = "";
    while(1)
    {
        printf("请输入>>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = '\0';
 
        //将数据发送给到管道中
        write(wfd, wbuf, strlen(wbuf));
 
        //判断数据
        if(strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }
 
    //关闭文件描述符
    close(wfd);
 
    
    return 0;
}

cd.c

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //以读的形式打开文件
    int rfd = open("./linux", O_RDONLY);
    if(rfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件读端打开\n");
     int tid = open("./1.txt", O_RDWR);
    if(rfd == -1)
    {
        perror("open error");
        return -1;
    }
    //定义接受容器
    char rbuf[128] = "";
    while(1)
    {
        bzero(rbuf, sizeof(rbuf));
        //读取数据
        read(rfd, rbuf, sizeof(rbuf));
        if(strcmp(rbuf, "quit") == 0)
        {
            break;
        }
        printf("收到消息为：%s\n", rbuf);
        write(tid,rbuf,sizeof(rbuf));
    }
 
    //关闭文件描述符
    close(rfd);
    close(tid);
    return 0;
}
 

2>    使用有名管道实现两个进程间相互通信

day1.c

#include <myhead.h>

int main(int argc, const char *argv[])
{
    //创建一个有名管道文件
    if (mkfifo("./linux", 0664) == -1)
    {
        perror("mkfifo error");
        return -1;
    }
        //创建一个有名管道文件
    if (mkfifo("./text", 0664) == -1)
    {
        perror("mkfifo error");
        return -1;
    }

    getchar();
    //删除管道文件
    system("rm linux");
    system("rm text");
    return 0;
}

dday1.c

#include <myhead.h>
int main(int argc, const char *argv[])
{
    //以写的形式打开管道文件
    int wfd = open("./linux", O_WRONLY);
    if (wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
    int rid = open("./text", O_RDONLY);
    if (rid == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
    int rp = -1;
    if ((rp = fork()) == -1)
    {
        perror("fork error\n");
    }
    if (rp > 0)
    {
        //发送数据
        char wbuf[128] = "";
        while (1)
        {
            printf("请输入>>>>\n");
            fgets(wbuf, sizeof(wbuf), stdin);
            wbuf[strlen(wbuf) - 1] = 0;

            //将数据发送给到管道中
            write(wfd, wbuf, strlen(wbuf));

            //判断数据
            if (strcmp(wbuf, "quit") == 0)
            {
                break;
            }
            //关闭文件描述符
        }
        close(wfd);
   
    }
    else
    {
        char sv[128] = "";
        while (1)
        {
            bzero(sv, sizeof(sv));
            read(rid, sv, sizeof(sv));
            if (strcmp(sv, "quit") == 0)
            {
                break;
            }
            printf("接收到的数据为%s\n", sv);
        }

   
        close(rid);
 

         exit(0);
    }

    wait(NULL);

    return 0;
}
day2.c

#include <myhead.h>
int main(int argc, const char *argv[])
{
    //以写的形式打开管道文件
    int wfd = open("./linux", O_RDONLY);
    if (wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
    int rid = open("./text", O_WRONLY);
    if (rid == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");
    int rp = -1;
    if ((rp = fork()) == -1)
    {
        perror("fork error\n");
    }
    if (rp > 0)
    {
        char sv[128] = "";
        while (1)
        {
            bzero(sv, sizeof(sv));
            read(wfd, sv, sizeof(sv));
            if (strcmp(sv, "quit") == 0)
            {
                break;
            }
            printf("接受到的数据为%s\n", sv);
        }
  
        close(wfd);
    }
    else
    {
        //发送数据
        char wbuf[128] = "";
        while (1)
        {
            printf("请输入>>>>\n");
            fgets(wbuf, sizeof(wbuf), stdin);
            wbuf[strlen(wbuf) - 1] = 0;

            //将数据发送给到管道中
            write(rid, wbuf, strlen(wbuf));

            //判断数据
            if (strcmp(wbuf, "quit") == 0)
            {
                break;
            }
            //关闭文件描述符
        }

   
    
        close(rid);

        exit(0);
    }

    wait(NULL);

    return 0;
}
 

相关文章：

day25

一、进程间通信&#xff08;IPC&#xff09; 1.1 进程间通信的引入 1> 对于多个线程之间通信&#xff0c;我们可以使用临界资源来完成&#xff0c;通过一个线程任务对临界资源进行修改&#xff0c;另一个线程也可以使用已经修改过的临界资源&#xff0c;但是要注意使用…...

编程日记 2024/8/6 23:15:58

红黑树的概念和模拟实现[C++]

文章目录 红黑树的概念一、红黑树的性质红黑树原理二、红黑树的优势和比较 红黑树的模拟实现构建红黑树的数据结构定义节点的基本结构和初始化方式插入新节点插入新节点的颜色调整颜色和结构以满足红黑树性质 红黑树的应用场景 红黑树的概念 一、红黑树的性质 红黑树是一种自平…...

编程日记 2024/8/6 23:14:56

网络安全应急响应概述

前言 在网络安全领域&#xff0c;有一句广为人知的话&#xff1a;“没有绝对的安全”。这意味着任何系统都有可能被攻破。安全攻击的发生并不可怕&#xff0c;可怕的是从头到尾都毫无察觉。当系统遭遇攻击时&#xff0c;企业的安全人员需要立即进行应急响应&#xff0c;以将影响…...

编程日记 2024/8/6 23:13:55

【C++】链表操作技巧综合：重排链表（带你理顺链表的做题思路）

1.题目 2.算法思路 这是一道关于链表的综合题&#xff0c;一共涉及到三个步骤&#xff0c;其中每个步骤单拎出来就可以当一道单独的题目。所以需要大家对链表的操作十分熟悉&#xff0c;否则可能需要大量的时间做这道题目&#xff0c;而且还要很多的bug。 第一个步骤&#xf…...

编程日记 2024/8/6 23:10:52

行为型设计模式2：观察者/职责链/中介者/访问者

设计模式&#xff1a;观察者/职责链/中介者/访问者 (qq.com)...

编程日记 2024/8/6 23:09:51

叛逆，批判

1、对以往说法的批判之一&#xff08;第一次这么公开批判是2004-2005年&#xff09;&#xff1a; 这部英文版的《数学百科全书》似乎是从俄语版翻译过来的&#xff1f;我查了三本引用的图书文献&#xff0c;都没有关于“nonsingular”和“singular”的类似下面的说法&#xff…...

编程日记 2024/8/6 23:08:47

Linux 命令，mkdir说明与使用

1&#xff1a;mkdir命令功用&#xff1a; 用于创建一个或多个目录&#xff0c;创建目录&#xff0c;必须在父目录中写上权限。 新目录的默认模式为0777&#xff0c;可以由系统或用的umask来修改。 2&#xff1a;命令构件: mkdir [options] directories 3:参数选项: -m&#x…...

编程日记 2024/8/6 23:07:46

24. 两两交换链表中的节点（Java）

目录 题目描述&#xff1a;示例 &#xff1a;代码实现&#xff1a; 题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&am…...

编程日记 2024/8/6 23:06:45

linux虚拟机设置固定ip

修改/etc/sysconfig/network-scripts目录下ifcfg-eth0文件&#xff0c;各虚拟机这个文件名不一致&#xff0c;ifcfg-XX格式 vim /etc/sysconfig/network-scripts/ifcfg-eth0BOOTPROTO设置为static&#xff0c;然后在最后添加固定IP地址和默认网关、DNS等配置&#xff0c;IP地址…...

编程日记 2024/8/6 23:04:43

mysql问题解决

1.etl数据同步时&#xff0c;发现连接不上要同步的数据库 解决方法&#xff1a;关闭mysql的ssl&#xff0c;步骤如下&#xff1a; 在MySQL中禁用SSL连接涉及修改服务器的配置文件&#xff08;通常是my.cnf或my.ini&#xff0c;取决于你的操作系统和MySQL版本&#xff09;。以…...

编程日记 2024/8/6 23:01:40

类和对象（下）C++

1.初始化列表 1.为什么有初始化列表&#xff0c;它的作用&#xff1f; ->初始化列表&#xff0c;是构造函数初始化的另一种形式。 ->在语法上面理解&#xff0c;初始化列表可以认定为是每个成员变量定义初始化的地方. ->引用成员变量&#xff0c;const成员变量&am…...

编程日记 2024/8/6 22:59:38

常用在线 Webshell 查杀工具推荐

一、简介 这篇文章将介绍几款常用的在线 Webshell 查杀工具&#xff0c;包括长亭牧云、微步在线云沙箱、河马和VirusTotal。每个工具都有其独特的特点和优势&#xff0c;用于帮助用户有效检测和清除各类恶意 Webshell&#xff0c;保障网站和服务器的安全。文章将深入探讨它们的…...

编程日记 2024/8/6 22:58:37

RPC远程调用框架Dubbo

一、分布式服务调用_什么是RPC RPC(Remote Procedure Call)远程过程调用&#xff0c;它是一种通过网络从远程计算机程序上请求服务。 大白话理解就是&#xff1a;RPC让你用别人家的东西就像自己家的一样。 RPC两个作用&#xff1a; 屏蔽远程调用跟本地调用的区别&#xff0c…...

编程日记 2024/8/6 22:57:36

基于STM32的智能灌溉系统

目录 引言环境准备工作 硬件准备软件安装与配置系统设计 系统架构硬件连接代码实现 初始化代码传感器读取和控制代码应用场景 农业灌溉花园自动灌溉常见问题及解决方案 常见问题解决方案结论 1. 引言 智能灌溉系统通过实时监测土壤湿度和环境温度&#xff0c;自动控制灌溉设…...

编程日记 2024/8/6 22:55:34

Datawhale AI 夏令营 Task3（半成品，仍在学习理解

课程链接 / 知识点整理 &#xff08;一&#xff09;...

编程日记 2024/8/6 22:54:33

细腻呵护静音生活缓冲器，家具中的隐形侍者

在忙碌的生活节奏中&#xff0c;家是我们寻找宁静与放松的避风港。而家具缓冲器&#xff0c;就像一位隐形的侍者&#xff0c;在不经意间为我们营造出温馨、宁静的居住环境。它们静静地工作&#xff0c;细腻地呵护着每一处细节&#xff0c;让家的每一次触碰成为一次尊享体验。 细…...

编程日记 2024/8/6 22:53:31

【MATLAB源码-第243期】基于simulink的CUK斩波电路仿真,输出各节点波形。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 CUK电路是一种高效的直流-直流转换器&#xff0c;它以其独特的能量传递方式和高效的电压转换能力&#xff0c;在许多电力电子应用中得到了广泛的使用。下面将详细描述CUK电路的工作原理、各个组成部分以及其在实际应用中的优…...

编程日记 2024/8/6 22:52:30

springboot项目不能同时跑junit4和junit5的解决方法

springboot项目的maven test只会跑junit4 RunWith注解的测试类&#xff0c;而不会跑junit5 ExtendWith的测试类 解决方法&#xff1a;pom加上以下plugin&#xff0c;版本号需要3.0.0-M5及以上 <plugin><groupId>org.apache.maven.plugins</groupId><art…...

编程日记 2024/8/6 22:50:29

【IO】使用消息队列完成两个进程之间相互通信

目录 1、使用消息队列完成两个进程之间相互通信 2、共享内存实现两个进程之间的通信 3、思维导图 1、使用消息队列完成两个进程之间相互通信 //msgsnd.c #include <myhead.h>// 要发送的消息类型 struct msgbuf {long mtype;char mtext[1024]; };// 定义一个宏&#…...

编程日记 2024/8/6 22:49:27

Web开发：用C#的逻辑理解VUE语法（VUE + Webapi小白开发笔记）

适用阅读对象&#xff1a;需要兼顾前端的C#后端开发人员&#xff08;基础笔记&#xff09; 目录 一、后端交互-获取实体数据 二、变量 1.声明 2.作用域 三、字符串的处理 四、数组(列表)的处理 1.数组中的SELECT语法&#xff08;提取特定字段到新数组&#xff09; 2.数…...

编程日记 2024/8/6 22:48:27

操作系统文件位置指针

文件位置指针 与标准IO的文件读写位置指针一样&#xff0c;系统IO时也会有一个表示位置的指针在移动&#xff0c;会随着读写操作的执行向后自动移动 当需要随机位置进行读写操作时&#xff0c;那么需要移动位置指针的位置 off_t lseek(int fd, off_t offset, int whence); 功…...

编程日记 2024/8/6 22:47:25

设计模式的概念

设计模式主要分为三类&#xff1a;创建类的设计模式、结构型设计模式、行为型设计模式。 创建类的设计模式&#xff1a;简单工厂&#xff0c;工厂模式&#xff0c;抽象工厂&#xff0c;建造者&#xff0c;单例&#xff0c;原型 结构型设计模式&#xff1a;代理模式、享元模式 行…...

编程日记 2024/8/6 22:45:24

VMware17下载与安装

1.下载 通过百度网盘分享的文件&#xff1a;VMware17 链接&#xff1a;https://pan.baidu.com/s/1gCine3d3Rp_l3NYAu5-ojg 提取码&#xff1a;ek25 --来自百度网盘超级会员V3的分享 2.安装...

编程日记 2024/8/6 22:44:23

mv命令学习

移动和重命名文件 mv mv命令的作用就是将文件系统的文件从一个地方移动到另一个地方。 $ pwd /home/scott/libby $ ls libby_arrowrock.jpg libby_bak.jpg libby.jpg ➥libby_on_couch.jpg on_floor $ ls ~/pictures/dogs libby_on_floor_01.jpg libby_on_floor_03.jpg li…...

编程日记 2024/8/6 22:43:22

西北航天基地采用Infortrend NAS存储做影视后期及共享

用户背景&#xff1a; 创建最早的综合型航空航天基地&#xff0c;占地5万平方米&#xff0c;每年约300天进行航天试验 挑战&#xff1a; 西北航天基地规模大任务多&#xff0c;分别有不同的项目组负责试验&#xff0c;项目组需要获取试验任务影像资料&#xff0c;用于分析总…...

编程日记 2024/8/6 22:41:19

GitHub每日最火火火项目（8.6）

项目名称&#xff1a;bghira / SimpleTuner 项目介绍&#xff1a;SimpleTuner是一个通用的微调工具包&#xff0c;主要面向Stable Diffusion 2.1、Stable Diffusion 3、DeepFloyd和SDXL等模型。它旨在为这些模型提供一种方便的方式进行微调&#xff0c;以适应不同的应用场景和需…...

编程日记 2024/8/6 22:40:17

LangChain与CI/CD的无缝对接：自动化部署的新前沿

LangChain与CI/CD的无缝对接&#xff1a;自动化部署的新前沿 在当今快速发展的软件开发领域&#xff0c;持续集成/持续部署&#xff08;CI/CD&#xff09;已成为提升开发效率和软件质量的关键实践。LangChain&#xff0c;作为一个假设的编程辅助工具&#xff0c;如果存在&…...

编程日记 2024/8/6 22:39:16

Laravel为什么会成为最优雅的PHP框架？

目录 1. 设计哲学 1.1 表达性语法 1.2 约定优于配置 1.3 优雅的异常处理 2. 核心特性 2.1 Eloquent ORM 2.2 路由系统 2.3 Blade模板引擎 2.4 Artisan命令行工具 3. 社区支持 3.1 丰富的文档和教程 3.2 Packalyst&#xff1a;丰富的扩展包 3.3 社区活动和会议 4.…...

编程日记 2024/8/6 22:38:14

LabVIEW中的Reverse String函数与字节序转换

在LabVIEW中&#xff0c;数据的字节序&#xff08;也称为端序&#xff09;问题通常出现在数据传输和存储过程中。字节序可以分为大端&#xff08;Big-Endian&#xff09;和小端&#xff08;Little-Endian&#xff09;&#xff0c;它们分别表示高字节存储在低地址和低字节存储在…...

编程日记 2024/8/6 22:37:14

用OpenCV与MFC写一个简单易用的图像处理程序

工厂里做SOP及测试报告以及员工资格鉴定等常需用到简单的图像处理&#xff0c;PS等软件正版费用不菲&#xff0c;学习起来成本也高。Windows自带的图像处理软件&#xff0c;用起来也不是那么得心应手。因此我用OpenCV与MFC写了一个简单易用的图像处理程序。 程序界面 基于简单…...

编程日记 2024/8/6 22:36:13