IO进程线程day9（2023.8.7）

最新推荐文章于 2024-08-28 21:25:50 发布
最新推荐文章于 2024-08-28 21:25:50 发布
阅读量207 收藏
点赞数
分类专栏： IO进程线程 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68542867/article/details/132152358
版权

一、Xmind整理：

消息队列的原理：

共享内存的原理：

二、课上练习：

练习1：用信号的方式回收僵尸进程（重点！）

1.子进程退出后，父进程会收到17)SIGCHLD信号。

2.父进程中捕获17)SIGCHLD信号，给该信号注册新的处理函数。在该新的处理函数中执行waitpid函数，回收僵尸进程。

3.当在信号A的处理函数内部时，再次触发A信号，会导致信号屏蔽，会造成多个子进程短时间内同时退出，父进程只会处理一个17号信号，导致僵尸进程收不干净的问题。

4.解决方式：当成功回收到僵尸进程后，再回收一次。直到没有僵尸进程，结束循环。即判断waitpid(-1, NULL, WNOHANG);的返回值

    ①  =0，有子进程，但是没有僵尸进程

    ②  =-1，没有子进程，也没有僵尸进程

小练1：回收一个子进程
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <head.h>
void handler(int sig)
{
    printf("触发%d信号\n",sig);
    pid_t wpid =waitpid(-1,NULL,WNOHANG);
    printf("wpid =%d\n",wpid);
    return;
}
int main(int argc, const char *argv[])
{
    pid_t cpid = fork();

    if(cpid > 0)
    {
        //捕获2号SIGINT信号
        if(signal(17,handler) == SIG_ERR)
        {
            perror("signal");
            return -1;
        }
        printf("捕获17号信号成功\n");
        while(1)                                                                              
        {
            printf("this id parent: %d %d\n",getpid(),cpid);
            sleep(1);
        }
    }
    else if(0 == cpid)
    {
        for(int i = 0; i<3; i++)
        {
            printf("this is cpid %d %d\n",getppid(),getpid());
            sleep(1);
        }
        printf("子进程　%d　准备退出\n",getpid());
        exit(0);
    }
    else
    {
        perror("fork");
        return -1;
    }

    return 0;
}
小练2：多个子进程短时间内同时退出问题
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <head.h>
#include <sys/wait.h>
int count = 0;
void handler(int sig)
{
    while(1)
    {   //当回收成功后，再收一次，直到回收失败
        //=-1,没有僵尸进程，也没有子进程
        //=0,没有僵尸进程，但是有子进程
        pid_t wpid = waitpid(-1,NULL,WNOHANG);
        if(wpid <= 0)
            break;
        printf("[%d] wpid = %d\n",++count,wpid);
    }
       /*
       也可以这样写
       while(waitpid(-1,NULL,WNOHANG) > 0);
       */                                                           

    return;
}
int main(int argc, const char *argv[])
{
    //捕获17号SIGINT信号
    if(signal(17,handler) == SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    printf("捕获17号信号成功\n");

    int i = 0;
    while(i < 100)
    {
        if(fork() == 0)   //若是子进程
        {
            exit(0);      //退出
        }
        i++;              //只有父进程执行i++
    }
    //能运行到当前位置，则代表是父进程
    while(1)
        sleep(1);

    return 0;
}

练习2：kill

功能：给指定进程或者进程组发送一个信号
原型：
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
参数：
pid_t pid：指定要发送的进程或者进程组;
pid > 0,  将信号发送给指定的进程，进程号==pid参数;
pid == 0, 将信号发送给当前进程组下的所有进程；
pid == -1, 将信号发送给当前进程权限所能送达的所有进程，除了1号进程;
pid < -1,  将信号发送给指定进程组下的所有进程。进程组ID == -pid参数；
int sig：指定要发送的信号的编号，可以填对应的宏；
sig==0代表没有信号被发送，但是依然会检测对方进程是否存在，或者是否有权限访问。
返回值：
成功，返回0；
失败，返回-1，更新errno;

练习3：alarm

功能：设置一个定时器，当时间到后，给当前进程发送一个14) SIGALRM 信号
原型：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
参数：
unsigned int seconds：设置定时器时间，以秒为单位;
seconds == 0, 则取消定时器;
返回值：
>0, 返回上一个定时器没有走完的时间;
=0, 没有未走完的定时器;
小练： 设置一个3s的定时器
 #include <stdio.h>
 #include <unistd.h>
 #include <signal.h>
 
 void callback(int sig)
 {
     printf("alarm...\n");
     alarm(3);     //设置一个3s的定时器
     return;
 }
 
 int main(int argc, const char *argv[])
 {
     //捕获14号信号
     if(signal(14,callback) == SIG_ERR)              
     {
         perror("signal");
         return -1;
     }
 
     alarm(3);    //设置一个3s的定时器
 
     while(1)
     {
         printf("signal...\n");
         sleep(1);
     }
     return 0;
 }

练习4：ftok

功能：该函数通过pathname提供的id，以及proj_id提供的8bit的值，计算key值（键值），给msgget shmget semget函数使用。只要pathname和proj_id一致，则计算的key值就一致。那么通过相同key值找到的IPC对象就是同一个。
原型：
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
参数：
char *pathname：文件的路径以及名字; 该文件必须存在且可访问
int proj_id：传入一个非0参数;
返回值：
成功，返回计算得到的key值;
失败，返回-1，更新errno;
小练： 创建消息队列
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int main(int argc, const char *argv[])
{
    //创建key值
    key_t key =ftok("/",1);
    if(key < 0)
    {
        perror("ftok");
        return -1;
    }
    printf("key = %#x\n",key);

    //创建消息队列
    int msqid = msgget(key,IPC_CREAT|0664);
    if(msqid < 0)
    {
        perror("msgget");
        return -1;
    }
    printf("msqid = %d\n",msqid);
    system("ipcs -q");               //让代码执行shell指令

    return 0;
}

练习5：msgget

功能：通过key值到内核内存中找对应的消息队列，并返回消息队列的id ---> msqid
原型：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);
参数：
key_t key：ftok函数返回出来的key值;
int msgflg：
        IPC_CREAT：若消息队列不存在，则创建消息队列。若消息队列存在，则忽略该选项;
        IPC_CREAT|0664：创建的同时指定消息队列的权限。
        IPC_CREAT|IPC_EXCL:若消息队列不存在，则创建消息队列。若消息队列存在，则报错;
返回值：
>=0, 成功返回消息队列的id号  msqid;
=-1, 函数运行失败，更新errno;

练习6：msgsnd

功能：将数据打包后发送到消息队列中
原型：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
参数：
int msqid：指定要发送到哪个消息队列中;
void *msgp：指定要发送的消息包的首地址; 通用格式如下：
struct msgbuf {
long mtype;       /* message type, must be > 0 */    消息类型，必须大于0；
char mtext[1];    /* message data */  消息内容，类型根据需求修改，想要发什么类型就填什么类型。
                                      大小与下一个参数msgsz指定的一致
              };   
size_t msgsz：消息内容的大小，以字节为单位。   
int msgflg：
0：阻塞方式发送，当消息队列满了，则当前函数阻塞;
IPC_NOWAIT：非阻塞方式，当消息队列满了，该函数不阻塞，且函数运行失败，errno == EAGAIN.
返回值：
=0, 函数运行成功;
=-1， 函数运行失败，更新errno;
小练： 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <head.h>
 #include <sys/ipc.h>
 #include <sys/msg.h>
 
 struct msgbuf
 {
     long mtype;
     char mtext[128];
 };
 
 int main(int argc, const char *argv[])
 {
     //创建key值
     key_t key =ftok("/",1);
     if(key < 0)
     {
         perror("ftok");
         return -1;
     }
     printf("key = %#x\n",key);
 
     //创建消息队列
     int msqid = msgget(key,IPC_CREAT|0664);
     if(msqid < 0)
     {
         perror("msgget");
         return -1;
     }
     printf("msqid = %d\n",msqid);
 
     struct msgbuf sndbuf;
     while(1)
     {
         printf("请输入消息类型:");
         scanf("%ld",&sndbuf.mtype);
         getchar();
 
         if(0 == sndbuf.mtype)   //若终端输入0，则跳出循环
             break;
         printf("请输入消息内容:");
         fgets(sndbuf.mtext,sizeof(sndbuf.mtext),stdin);
         sndbuf.mtext[strlen(sndbuf.mtext)-1] = 0;
 
         //向消息队列中发送数据
         if(msgsnd(msqid,&sndbuf,sizeof(sndbuf.mtext),0)< 0)
         {
             perror("msgsnd");
             return -1;
         }
         printf("发送成功\n");
         system("ipcs -q");               //让代码执行shell指令
     }
     return 0;
 }

练习7：msgrcv

功能：从消息队列中读取数据
原型：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
参数：
int msqid: 指定要从哪个消息队列中读取消息;
void *msgp：指定将读取到的数据存储到什么位置，填对应空间的地址; 以什么形式写入，就以什么形式读取。通用格式如下：
struct msgbuf {
long mtype;       /* message type, must be > 0 */    消息类型，必须大于0；
char mtext[1];    /* message data */  消息内容，类型根据需求修改，想要发什么类型就填什么类型。
                                      大小与下一个参数msgsz指定的一致
              };   
size_t msgsz：指定要读取多少个字节大小的消息内容，以字节为单位。   
long msgtyp：指定要读取的消息类型; 
msgtyp == 0, 读取消息队列中的第一条消息; 先进先出；
msgtyp > 0,  指定消息类型读取，读取消息队列中第一条消息类型为 msgtyp参数指定的消息；
msgflg指定了MSG_EXCEPT，读取消息队列中第一条消息类型 不等于 msgtyp参数指定的消息；
vi -t MSG_EXCEPT;   #define MSG_EXCEPT      020000 
msgtyp < 0,  读取消息队列中第一条最小的，且类型小于等于 msgtyp参数绝对值的消息。                  
int msgflg：
0：阻塞方式，当消息队列中没有消息了，该函数阻塞;
IPC_NOWAIT：非阻塞方式运行，当消息队列中没有消息了，该函数不阻塞，运行失败，errno == ENOMSG;
返回值：
>0, 成功读取到的字节数;
=-1, 函数运行失败，更新errno;
代码示例： 

若消息队列中有消息：

                                   mtype     100      101      99      100      101

                                   mtext       aaa     bbb     ccc     ddd     eee

 i. msgtyp == 0
while(1)                                                                   
    {
        //阻塞方式读取消息队列中第一条消息，先进先出的原则
        //res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), 0, 0);
        
        //非阻塞方式读取消息队列中第一条消息，先进先出的原则
        res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), 0, IPC_NOWAIT);
        if(res < 0)
        {
            perror("msgrcv");
            return -1;
        }
        printf("res=%ld : %ld %s\n", res, rcv.mtype, rcv.mtext);
    }
​
输出顺序：
    100 aaa   101 bbb   99 ccc   100 ddd    101 eee
ii. msgtyp > 0 
while(1)
    {
        //1.阻塞方式读取消息队列中第一条消息类型 == 101 的消息
        //res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), 101, 0);
​
        //2.非阻塞方式读取消息队列中第一条消息 == 101 的消息
        //res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), 101, IPC_NOWAIT);
                                                                                  
        //3.非阻塞方式读取消息队列中第一条消息类型 != 101的消息 
        res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), 101, IPC_NOWAIT|020000);
        if(res < 0)
        {
            perror("msgrcv");
            return -1;
        }
        printf("res=%ld : %ld %s\n", res, rcv.mtype, rcv.mtext);
    }
注释1,2的现象：
    101 bbb     101 eee
第3个的现象：
    100 aaa    99 ccc   100 ddd
iii.msgtyp < 0
 while(1)
    {
        //阻塞方式读取消息队列中<=msgtyp参数指定的消息类型中最小的那条消息;
        res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), -100, 0);
       
        //非阻塞方式读取消息队列中<=msgtyp参数指定的消息类型中最小的那条消息;
        //res = msgrcv(msqid, &rcv, sizeof(rcv.mtext), -100, IPC_NOWAIT);
​
        if(res < 0)
        {
            perror("msgrcv");
            return -1;
        }
        printf("res=%ld : %ld %s\n", res, rcv.mtype, rcv.mtext);
    }
​
现象：
res=128 : 99 ccc
res=128 : 100 aaa
res=128 : 100 ddd

练习8：msgctl

功能：控制消息队列，常用于删除消息队列
原型：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
参数：
int msqid：指定要控制的消息队列的id号;
int cmd：
        IPC_STAT：获取消息队列的属性,属性存储在第三个参数中;
        IPC_SET：设置消息队列属性，属性存储在第三个参数中;
        IPC_RMID：删除消息队列，第三个参数无效，填NULL即可;
返回值：
成功，返回0；
失败，返回-1，更新errno;
//删除消息队列
    if(msgctl(msqid, IPC_RMID, NULL) < 0)
    {
        perror("msgctl");
        return -1;
    }
    printf("删除消息队列成功\n");

练习9：共享内存函数   ftok

功能：该函数通过pathname提供的id，以及proj_id提供的8bit的值，计算key值（键值），给msgget shmget semget函数使用。只要pathname和proj_id一致，则计算的key值就一致。那么通过相同key值找到的IPC对象就是同一个。
原型：
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
参数：
char *pathname：文件的路径以及名字; 该文件必须存在且可访问
int proj_id：传入一个非0参数;
返回值：
成功，返回计算得到的key值;
失败，返回-1，更新errno;

练习10：shmget

功能：通过key值到内核内存中找对应的共享内存，并返回共享内存的id ---> shmid
原型：
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
参数：
key_t key：ftok函数返回出来的key值;
size_t size：指定要申请多少个字节的共享内存；
int shmflg：
        IPC_CREAT：若消息队列不存在，则创建共享内存。若共享内存存在，则忽略该选项;
        IPC_CREAT|0664：创建的同时指定共享内存的权限。
        IPC_CREAT|IPC_EXCL:若共享内存不存在，则创建共享内存。若共享内存存在，则报错;
返回值：
>=0, 成功返回共享内存的id号  shmid;
=-1, 函数运行失败，更新errno;

练习11：shmat

功能：将共享内存映射到用户空间中
原型：
#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
参数：
int shmid：指定要映射的共享内存id号 , 
const void *shmaddr：指定共享内存要映射到用户空间的位置，填对应空间的首地址; 例如：(void*)0x10
                     填NULL，代表让操作系统自动映射;
int shmflg :
        0：默认方式映射，进程对共享内存可读可写;
        SHM_RDONLY：只读，进程对共享内存只读;
返回值：
成功，返回共享内存映射到用户空间的首地址;
失败，返回 (void *) -1，更新errno;
注意：获取到的映射空间的首地址的指向不允许修改，若修改后会导致首地址找不到，导致内存泄漏，与堆空间首地址不能改变的概念一致

小练： 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <head.h>
#include <sys/ipc.h>
int main(int argc, const char *argv[])
{
    //创建key值
    key_t key = ftok("./",10);
    if(key < 0)
    {
        perror("ftok");
        return -1;
    }
    printf("key = %#x\n",key);

    //创建共享内存，获得shmid号
    int shmid =shmget(key, 32, IPC_CREAT|0664);
    if(shmid < 0)
    {
        perror("shmget");
        return -1;                                 
    }
    printf("shmid = %d\n",shmid);

    //映射共享内存到用户空间
    void* addr = shmat(shmid,NULL,0);
    if((void*)-1 == addr)
    {
        perror("shmat");
        return -1;
    }
    printf("addr = %p\n",addr);
    system("ipcs -m");

    return 0;
}

练习12：shmdt

功能：将共享内存与进程的用户空间断开映射； 当进程不想操作共享内存的时候，就可以断开映射
原型：
#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);
参数：
void *shmaddr：指定要断开映射的用户空间的首地址
返回值：
成功，返回0;
失败，返回-1，更新errno;

练习13：shmctl

功能：控制共享内存，常用于删除共享内存
原型：
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数：
int shmid：指定要控制的共享内存;
int cmd：
        IPC_STAT：获取共享内存的属性,属性存储在第三个参数中;
        IPC_SET：设置共享内存属性，属性存储在第三个参数中;
        IPC_RMID：删除共享内存，第三个参数无效，填NULL即可;
返回值：
成功，返回0;
失败，返回-1，更新errno;
//删除共享内存
    if(shmctl(shmid, IPC_RMID, NULL) < 0)
    {
        perror("shmctl");
        return -1;
    }
    printf("删除共享内存成功\n");

三、课后作业：

1.要求用消息队列实现AB进程对话

   A进程先发送一句话给B进程，B进程接收后打印

   B进程再回复一句话给A进程，A进程接收后打印

   重复1.2步骤，当收到quit后，要结束AB进程

   实现随时收发：用多进程 多线程。

A进程：
#include <stdio.h>
#include <string.h>
#include <head.h>

struct msgbuf
{
    long mtype;
    char mtext[128];
};
int main(int argc, const char *argv[])
{
    //创建key值
    key_t key =ftok("./",1);

    if(key < 0)
    {
        perror("ftok");
        return -1;
    }
    printf("key = %#x\n",key);

    //创建消息队列                                                   
    int msqid = msgget(key,IPC_CREAT|0664);
    if(msqid < 0)
    {
        perror("msgget");
        return -1;
    }
    printf("msqid = %d\n",msqid);

    struct msgbuf sndbuf;
    //创建一个子进程
    pid_t cpid = fork();
    if(cpid > 0)
    {
        while(1)
        {
            sndbuf.mtype = 1;
            scanf("%s",sndbuf.mtext);
            msgsnd(msqid,&sndbuf,sizeof(sndbuf.mtype),0);
            if(strcmp(sndbuf.mtext,"quit") == 0)
                break;
        }
    }
    else if(0 == cpid)
    {
        while(1)
        {
            msgrcv(msqid,&sndbuf,sizeof(sndbuf.mtext),2,0);
            if(strcmp(sndbuf.mtext,"quit") == 0)
                break;
            printf("%s\n",sndbuf.mtext);
        }
        kill(getppid(),2);
    }
    else
    {
        perror("fork");
        return -1;
    }
    return 0;
}
B进程：
#include <stdio.h>
#include <string.h>
#include <head.h>
struct msgbuf
{
    long mtype;
    char mtext[128];
};
int main(int argc, const char *argv[])
{
    key_t key = ftok("./",1);
    if(ftok < 0)
    {
        perror("ftok");
        return -1;                                                       
    }
    printf("key = %#x\n",key);

    int msqid = msgget(key,IPC_CREAT|0664);
    if(msqid < 0)
    {
        perror("msgget");
        return -1;
    }

    struct msgbuf sndbuf;
    pid_t cpid = fork();
    if(cpid > 0)
    {
        while(1)
        {
            sndbuf.mtype = 2;
            scanf("%s",sndbuf.mtext);
            msgsnd(msqid,&sndbuf,sizeof(sndbuf.mtype),0);
            if(strcmp(sndbuf.mtext,"quit") == 0)
                break;
        }
    }

    else if(0 == cpid)
    {
        while(1)
        {
            msgrcv(msqid,&sndbuf,sizeof(sndbuf.mtext),1,0);
            if(strcmp(sndbuf.mtext,"quit") == 0)
                break;
            printf("%s\n",sndbuf.mtext);
        }
        kill(getppid(),2);
    }
    else
    {
        perror("fork");
        return -1;
    }

    return 0;
}

2.要求在共享内存中存入字符串 “1234567”。A进程循环打印字符串，B进程循环倒置字符串，要求结果不允许出现乱序：

提示：共享内存中存储 flag + string.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <head.h>
#include <sys/shm.h>
int main(int argc, const char *argv[])
{
    //创建key值
    key_t key = ftok("./", 3);
    if(key < 0)
    {
        perror("ftok");
        return -1;
    }
    printf("key = %#x\n", key);

    //通过key值获取shmid号
    int shmid = shmget(key, 32, IPC_CREAT|0777);
    if(shmid < 0)
    {
        perror("shmget");
        return -1;
    }
    printf("shmid = %d\n", shmid);

    //将共享内存映射到用户空间
    void* addr = shmat(shmid, NULL, 0);
    if((void*)-1 == addr)
    {
        perror("shmat");
        return -1;
    }                                                                            
    printf("addr = %p\n", addr);

    //存储一个str
    *(int *)addr = 0;
    char *str = (char *)addr+4;
    //存储一个字符串
    strcpy(str,"1234567");
    pid_t cpid = fork();
    if(cpid > 0)
    {
        while(1)
        {
            if(*(int *)addr == 0)
            {
                printf("%s\n",(char *)addr+4);
                *(int *)addr = 1;
            }
        }
    }
    else if(0 == cpid)
    {
        while(1)
        {
            if(*(int*)addr == 1)
            {
                char *star = (char *)addr+4;
                char *end  = (char*)addr+4+strlen(str)-1;
                while(star<end)
                {
                    char temp = *star;
                    *star = *end;
                    *end  = temp;
                    star++;
                    end--;
                }
                *(int*)addr = 0;
            }
        }
    }
    else
    {
        perror("fork");
        return -1;
    }

    system("ipcs -m");

    return 0;
}

小徐今天认真学习了嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO进程线程day7（2023.8.4）
m0_68542867的博客
08-04 169
进程和线程的区别（重点！！！！！）、条件变量【工作原理、pthread_cond_init、pthread_cond_wait、pthread_conde_signal、pthread_cond_destroy】、信号量【工作原理、sem_init、sem_wait（P操作）、sem_post（V操作）、sem_destroy】
IO进程线程day8（2023.8.6）
m0_68542867的博客
08-07 139
什么是IPC机制【IPC机制、传统的进程间通信机制、system v操作系统的IPC对象、可用于跨主机传输的通信】 管道【管道的原理、管道的特性、无名管道（pipe）、有名管道（fifo）】 信号（signal）【信号的概念、信号的原理、进程对信号的处理方式（重点）、常见的信号、信号相关的函数】以及代码实现 要求实现AB进程对话 A进程先发送一句话给B进程，B进程接收后打印 B进程再回复一句话给A进程，A进程接收后打印 重复1.2步骤，当收到quit后，要结束AB进程
2023.05.11 IO进程线程 DAY8
qq_42328433的博客
05-11 176
练习
2023.05.05 IO进程线程DAY4
qq_42328433的博客
05-05 465
练习
2023.05.06 IO进程线程DAY5
qq_42328433的博客
05-06 367
练习
IO进程线程day5（2023.8.2）
m0_68542867的博客
08-02 165
进程的相关函数【fork、getpid、getppid、_exit、exit、wait、waitpid】 Linux中的特殊进程【孤儿进程、僵尸进程、守护进程】
IO进程线程day6（2023.8.3）
m0_68542867的博客
08-03 176
线程的概念【什么是线程、线程是任务运行的最小单位、进程和线程的区别】 线程相关的函数【pthread_create、线程的传参、pthread_exit、pthread_join、pthread_detach、pthread_cancel】 线程的同步互斥【互斥锁、条件变量、信号量】 互斥锁【工作原理、pthread_mutex_init、pthread_mutex_lock、pthread_mutex_unlock、pthread_mutex_destroy、死锁】
IO进程线程day4（2023.8.1）
m0_68542867的博客
08-01 228
获取文件属性、目录相关函数【opendir、closedir、readdir】、什么是进程、进程的5态图、进程的内存分布、进程是资源分配的最小单位、进程标识、进程相关的shell指令、进程相关函数【fork】
IO进程线程day1（2023.7.25）
m0_68542867的博客
07-25 353
IO进程线程、什么是IO、IO的分类、标准IO函数（fopen、perror、fclose、fprintf、fscanf、fgetc、fputc）
兑吧开发规范《源Java手册》
海客森
12-31 3169
1. 规范: 语法规范 1.1. 命名规范 【推荐】业务属性：对象、方法命名，要使用携带业务属性的名词，比如AdvertVO；反例DeleteVO；除非单纯对该对象操作，而对象具备了名词意义，比如AdvertVO中包含方法，getAccountByVO(AdvertVO advertVO) 【强制】代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式 说明: 正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，即使是纯拼音命名方式也要避免采用。 正例: alibaba / taba
超全！Python 处理日期与时间的全面总结！
Python宋宋的专栏
07-08 6102
Python的时间处理模块在日常的使用中用的较多多，但是使用的时候基本上都是要查资料，还是有些麻烦的，梳理下，便于以后方便的使用。时间相关概念Python time模块时间格式化计时器功能time模块其他内置函数time模块包含的属性datetime模块date类time类datetime类timedelta类tzinfo类pytz模块时区转换夏令时处理dateutil模块parser.parse()rrule.rrule()ArrowUTC 时间当地时间解析时间Unix 时间戳格式化日期和时间转换为区域时
JAVA经典面试题附答案(持续更新版)
热门推荐
hjseo_seg的博客
06-23 1万+
前言: 少年易老学难成，一寸光阴不可轻。未觉池塘春草梦，阶前梧叶已秋声 。—朱熹《劝学诗》 勤奋才是改变你命运的唯一捷径。 整理不易,各位看官点赞再看更舒适，养成好习惯(●′｀●)1.JAVA中的几种基本类型，各占用多少字节？ 下图单位是bit,非字节 1B=8bit 2.String能被继承吗？为什么？ 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”abc”(直接赋一个字面量);其实和String str=
Python定时任务与周期任务(任务调度)
Java/Python大数据成长之路
08-27 1429
Event是APScheduler在执行任务时触发的事件，用户可以自定义一些函数来监听这些事件，当触发某些Event时(任务抛出异常后)，做一些具体操作。APScheduler包含四大组件：调度器(scheduler)，作业存储(job store)，触发器(trigger)，执行器(executor)sched是Python的标准库之一，sched是事件调度器，它通过Scheduler类来调度事件，可用于定时任务或周期任务。默认情况下调度器会等待所有正在运行的作业完成后，关闭所有的调度器和作业存储；
【ray】【配置日志记录】
wq6qeg88的博客
03-12 1371
默认情况下，Ray 会删除跨多个进程冗余出现的日志的重复数据。这是代理的日志文件，包含创建或删除请求以及缓存命中和未命中的日志。有关实际安装的日志（例如，例如，如果您有大量工作角色 Actor，您可能希望轻松查看记录特定消息的 Actor 的索引。若要处理日志并将其导出到外部存储或管理系统，请查看 Kubernetes 上的日志持久性和 VM 上的日志持久性，了解更多详细信息。因此，每当您的集群或某些节点停止或终止时，日志文件都可能丢失。从广义上讲，存在两种类型的日志文件：系统日志文件和应用程序日志文件。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 539
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 2927
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
冒泡排序算法
最新发布
m0_74051652的博客
08-28 656
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
【算法】深入浅出聚类算法：原理、应用与Java实现
一个不断前行的程序者
08-26 1248
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
Socket.IO API 教程与示例
在这个例子中，`io.on('connection', ...)` 监听新连接，当客户端连接时，服务器会发送 `'news'` 事件，并在接收到客户端的 `'myotherevent'` 事件时打印数据。 ### 使用 Express 3/4 如果你的项目已经使用了 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值