IO进程day07（信号灯集、消息队列）

于 2024-09-02 21:56:00 发布
阅读量567 收藏 5
点赞数 19
文章标签： 算法 c# 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dghbs/article/details/141830889
版权

【1】信号灯集 semaphore

1》概念

信号灯(semaphore)，也叫信号量，信号灯集是一个信号灯的集合。它是不同进程间或一个给定进程内部不同线程间同步的机制；

而Posix信号灯指的是单个计数信号灯：无名信号灯、有名信号灯。（咱们学的是无名信号灯）

System V的信号灯是一个或者多个信号灯的一个集合。其中的每一个都是单独的计数信号灯。

通过信号灯集实现共享内存的同步操作

 2》步骤

（1）创建key值

（2）创建或打开信号灯集：semget

（3）初始化信号灯：semctl

（4）PV操作：semop

（5）删除信号灯集：semctl

3》命令

ipcs -s：查看信号灯集

ipcrm -s semid：删除信号灯集

注意：有时候可能会创建失败，或者semid为 0，所以用命令看看semid是否为0 ，若为0就删了重新创建就可以了。

4》函数接口

int semget(key_t key, int nsems, int semflg);

功能：创建/打开信号灯

参数：key：ftok产生的key值

           nsems：信号灯集中包含的信号灯数目

           semflg：信号灯集的访问权限，通常为IPC_CREAT|IPC_EXCL|0666

返回值：成功：信号灯集ID

              失败：-1

int semctl ( int semid, int semnum, int cmd…/*union semun arg*/);

功能：信号灯集合的控制（初始化/删除）

参数：semid：信号灯集ID

           semnum: 要操作的集合中的信号灯编号，信号灯编号从0开始

           cmd：

                 GETVAL：获取信号灯的值，返回值是获得值

                 SETVAL：设置信号灯的值，需要用到第四个参数：共用体

                 IPC_RMID：从系统中删除信号灯集合

返回值：成功 0

              失败 -1

用法：

1. 初始化信号灯集中信号灯:

需要自定义共用体:

union semun

{

int val;

};

union semun mysemun;

mysemun.val=10;

semctl(semid, 0, SETVAL, mysemun);

2. 获取信号灯值: 函数 semctl(semid,0,GETVAL); 的返回值

3. 删除信号灯集: semctl(semid,0,IPC_RMID); 这里传任意一个信号灯的编号就可以删除整个信号灯集了

int semop ( int semid, struct sembuf *opsptr, size_t nops);

功能：对信号灯集合中的信号量进行PV操作

参数：semid：信号灯集ID

           opsptr:操作方式

           nops: 要操作的信号灯的个数 1个

返回值：成功 ：0

              失败：-1

struct sembuf {

short sem_num; // 要操作的信号灯的编号

short sem_op; // 0 : 等待，直到信号灯的值变成0

// 1 : 释放资源，V操作

// -1 : 申请资源，P操作

short sem_flg; // 0（阻塞）,IPC_NOWAIT, SEM_UNDO

};

用法：

申请资源操作：

struct sembuf mysembuf;

mysembuf.sem_num=0;

mysembuf.sem_op=-1;

mysembuf.sem_flg=0;

semop(semid,&mysembuf,1);

释放资源操作：

mysembuf.sem_num=1;

mysembuf.sem_op=1;

mysembuf.sem_flg=0;

semop(semid,&mysembuf,1);

 创建信号灯集

使用信号灯集 

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
union semun
{
    int val;
};

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        union semun sem;
        sem.val = 10;
        semctl(semid, 0, SETVAL, sem); //把0号信号灯初始化值为10

        sem.val = 0;
        semctl(semid, 1, SETVAL, sem); //把1号信号灯初始化值为0
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    //PV操作
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = 0;
    buf.sem_op = -1; //申请资源，P操作，-1
    buf.sem_flg = 0; //阻塞
    semop(semid, &buf, 1); //对0号灯进行P操作申请资源

    buf.sem_num = 1;
    buf.sem_op = 1;  //释放资源，V操作，+1
    buf.sem_flg = 0; //阻塞
    semop(semid, &buf, 1); //对1号灯进行V操作释放资源

    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    // //删除信号灯集
    // semctl(semid, 0, IPC_RMID);   //任意传一个信号灯的编号就可以删除整个信号灯集了
    return 0;
}

封装函数操作

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 10); //把0号信号灯初始化值为10
        init(semid, 1, 0);  //把1号信号灯初始化值为0
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    //PV操作
    pv(semid, 0, -1); //对0号灯P操作
    pv(semid, 1, 1);  //对1号灯V操作

    printf("%d\n", semctl(semid, 0, GETVAL));
    printf("%d\n", semctl(semid, 1, GETVAL));

    // //删除信号灯集
    // semctl(semid, 0, IPC_RMID);   //任意传一个信号灯的编号就可以删除整个信号灯集了
    return 0;
}

把信号灯集加到共享内存实现同步：输入输出quit结束 

scanf：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
#include <sys/shm.h>
#include <string.h>

union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;
    int shmid;
    char *p;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
            shmid = shmget(key, 128, 0777);
        else
        {
            perror("shmget er");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 0); //把0号信号灯初始化值为0
        init(semid, 1, 1); //把1号信号灯初始化值为1
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("sem0: %d\n", semctl(semid, 0, GETVAL));
    printf("sem1: %d\n", semctl(semid, 1, GETVAL));

    while (1)
    {
        pv(semid, 1, -1);
        scanf("%s", p);
        pv(semid, 0, 1);
        if (strcmp(p, "quit") == 0)
            break;
    }

    shmdt(p);                      //取消映射
    // shmctl(shmid, IPC_RMID, NULL); //删除共享内存
    // semctl(semid, 0, IPC_RMID);    //删除信号灯集
    return 0;
}

printf：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
#include <sys/shm.h>
#include <string.h>

union semun
{
    int val;
};

//初始化
void init(int semid, int num, int val)
{
    union semun sem;
    sem.val = val;
    semctl(semid, num, SETVAL, sem); //把num号信号灯初始化值为val
}

//PV操作
void pv(int semid, int num, int op)
{
    struct sembuf buf; //sembuf结构体人家写好的直接拿来用就可以
    buf.sem_num = num;
    buf.sem_op = op;
    buf.sem_flg = 0;       //阻塞
    semop(semid, &buf, 1); //对num号灯进行op操作
}

int main(int argc, char const *argv[])
{
    key_t key;
    int semid;
    int shmid;
    char *p;

    if ((key = ftok("sem.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //创建或打开共享内存
    shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0777);
    if (shmid <= 0)
    {
        if (errno == EEXIST)
            shmid = shmget(key, 128, 0777);
        else
        {
            perror("shmget er");
            return -1;
        }
    }
    printf("shmid: %d\n", shmid);

    //映射共享内存
    p = (char *)shmat(shmid, NULL, 0);
    if (p == (char *)-1)
    {
        perror("shmat err");
        return -1;
    }

    //创建或打开信号灯集
    semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0777);
    if (semid <= 0)
    {
        if (errno == EEXIST)
            semid = semget(key, 2, 0777);
        else
        {
            perror("semget er");
            return -1;
        }
    }
    else //确保对信号灯集中的信号灯始终初始化一次，下次执行程序还继续获得上一次的值。如果修改初值，需要删除信号灯然后重新打开。
    {
        //初始化信号灯
        init(semid, 0, 0); //把0号信号灯初始化值为0
        init(semid, 1, 1); //把1号信号灯初始化值为1
    }
    printf("semid: %d\n", semid);

    //获取信号灯值
    printf("sem0: %d\n", semctl(semid, 0, GETVAL));
    printf("sem1: %d\n", semctl(semid, 1, GETVAL));

    while (1)
    {
        pv(semid, 0, -1);
        if (strcmp(p, "quit") == 0)
            break;
        printf("shm: %s\n", p);
        pv(semid, 1, 1);
    }

    shmdt(p);                      //取消映射
    shmctl(shmid, IPC_RMID, NULL); //删除共享内存
    semctl(semid, 0, IPC_RMID);    //删除信号灯集
    return 0;
}

【2】消息队列  message queue

1》概念

消息队列是IPC对象(活动在内核级别的一种进程间通信的工具)的一种

一个消息队列由一个标识符 (即队列ID)来标识

消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等

消息队列可以按照类型(自己设一个值作为类型)来发送/接收消息

2》步骤 

（1）创建key值：ftok

（2）创建或打开消息队列：msgget

（3）添加消息：按照消息的类型把消息添加到已经打开的消息队列末尾：msgsnd

（4）读取消息：可以按照消息类型把消息从消息队列中取走：magrcv

（5）删除消息队列：msgctl

3》操作命令

ipcs -q：查看消息队列

ipcrm -q msgid：删除消息队列

 4》函数接口

int msgget(key_t key, int flag);

功能：创建或打开一个消息队列

参数： key值

           flag：创建消息队列的权限IPC_CREAT|IPC_EXCL|0666

返回值：成功：msgid

              失败：-1

int msgsnd(int msqid, const void *msgp, size_t size, int flag);

功能：添加消息

参数：msqid：消息队列的ID

           msgp：指向消息的指针。常用消息结构msgbuf如下：

struct msgbuf{

long mtype; //消息类型

char mtext[N]；//消息正文

}；

           size：发送的消息正文的字节数

           flag：IPC_NOWAIT消息没有发送完成函数也会立即返回

           0：直到发送完成函数才返回

返回值：成功：0

              失败：-1

用法： msgsnd(msgid, &msg, sizeof(msg)-sizeof(long),0);

int msgrcv(int msgid, void* msgp, size_t size, long msgtype, int flag);

功能：读取消息

参数：msgid：消息队列的ID

           msgp：存放读取消息的空间

           size：接受的消息正文的字节数(sizeof(msgp)-sizeof(long))

           msgtype：

                  0：接收消息队列中第一个消息。

                  大于0：接收消息队列中第一个类型为msgtyp的消息.

                  小于0：接收消息队列中类型值不小于msgtyp的绝对值且类型值又最小的消息。

          flag：

                  0：若无消息函数会一直阻塞

                  IPC_NOWAIT：若没有消息，进程会立即返回ENOMSG

返回值：成功：接收到的消息的长度

              失败：-1

int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );

功能：对消息队列的操作，删除消息队列

参数：msqid：消息队列的队列ID

           cmd：

                    IPC_STAT：读取消息队列的属性，并将其保存在buf指向的缓冲区中。

                    IPC_SET：设置消息队列的属性。这个值取自buf参数。

                    IPC_RMID：从系统中删除消息队列。

            buf：消息队列缓冲区

返回值：成功：0

              失败：-1

用法：msgctl（msgid, IPC_RMID, NULL）；

打开或创建消息队列

 

 操作消息队列

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>

struct msgbuf
{
    long type; //必须有，在第一个，表示消息的类型，值>0!
    int num;   //消息正文，自己定义
    char ch;
};

int main(int argc, char const *argv[])
{
    key_t key;
    int msgid;

    if ((key = ftok("msg.c", 'a')) < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key: %#x\n", key);

    //打开或创建消息队列
    msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0777);
    if (msgid <= 0)
    {
        if (errno == EEXIST)
            msgid = msgget(key, 0777); //如果已经存在消息队列那直接打开该消息队列
        else
        {
            perror("msgget err");
            return -1;
        }
    }
    printf("msgid: %d\n", msgid);

    //添加消息
    struct msgbuf msg;
    msg.type = 10;
    msg.num = 1000;
    msg.ch = 'a';
    msgsnd(msgid, &msg, sizeof(msg) - sizeof(long), 0); //0:发完消息再返回，而不是立即返回函数

    msg.type = 20;
    msg.num = 2000;
    msg.ch = 'b';
    msgsnd(msgid, &msg, sizeof(msg) - sizeof(long), 0);

    //读取消息
    struct msgbuf m;
    msgrcv(msgid, &m, sizeof(m) - sizeof(long), 20, 0); //0:阻塞，读完消息再返回

    printf("%d %c\n", m.num, m.ch);

    //删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

 进程间通信

 今天的分享就到这里结束啦，如果有哪里写的不好的地方，请指正。
如果觉得不错并且对你有帮助的话点个关注支持一下吧！ 

欢'
关注
  • 19
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day34 事件驱动模型 and IO模型
gaosong0623的博客
09-29 143
传统的编程是如下线性模式的： 开始--->代码块A--->代码块B--->代码块C--->代码块D--->......--->结束 每一个代码块里是完成各种各样事情的代码，但编程者知道代码块A,B,C,D...的执行顺序，唯一能够改变这个流程的是数据。输入不同的数据，根据条件语句判断，流程或许就改为A--->C--->E...--->结束。...
L5进程、线程和进程间通信--有名管道和无名管道（day6）
楚子航
05-31 655
一、进程间通信介绍 概念：就是进程和进程之间交换信息。 常用通信方式 无名管道（pipe） 有名管道 （fifo） 信号（signal） 共享内存(mmap) 套接字（socket） 过时的IPC通信方式 System V IPC 共享内存（share memory） 消息队列（message queue） 信号灯集（semaphore set） 二、无名管道 无名管道具有如下特点： 只能用于具有亲缘关系的进程之间的通信 单工的通信模式，具有固定的读端和写端 无名管道创建时会返回两个文件描述
0807|IO进程线程day9 IPC对象概念及示例（消息队列、共享内存、信号灯集）
Smallxu_的博客
08-07 500
IPC机制：Inter Process Communication，即进程间通信机制。进程与进程间的用户空间相互独立，内核空间共享。所以如果要实现进程间的通信，需要使用进程间通信机制。
IO和进程day08（消息队列、共享内存、信号灯集）
weixin_53762703的博客
09-14 236
明日即考，量多待复，汝甚忧之。
Linux C语言学习 IO：day6 共享内存，信号灯级，消息队列
haogewudi666的博客
06-17 402
【1】复习 进程间通信方式 无名管道： 具有亲缘关系的进程 有固定读端fd[0]和写端fd[1] pipe(fd) 在内存中的3-4g的内核空间 管道中没有数据，读阻塞 管道中数据满了，写阻塞， 有名管道： 两个不相干的进程 在文件系统中存在管道文件名 mkfifo->open->read/write O_WRONLY:写阻塞 O_RDONLY：读阻...
IO进程day06（进程间通信、信号、共享内存）
dghbs的博客
08-30 1491
（3）只有在管道的读端存在时，向管道中写入数据才有意义，否则，会导致管道破裂，向管道中写入数据的进程将收到内核传来的SIGPIPE信号（通常Broken pipe错误）系统默认对SIGALRM(闹钟到点后内核发送的信号)信号的响应： 如果不对SIGALRM信号进行捕捉或采取措施，默认情况下，闹钟响铃时刻会退出进程。（2）信号可以直接进行用户空间进程和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件。（2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程。
Linux C语言学习 day5： 进程间的通信方式
haogewudi666的博客
06-17 355
【1】复习 线程：基本概念和特点： 创建线程：pthread_create 线程退出：pthread_exit 线程阻塞：pthread_join gcc xx.c -lpthread 同步：多个线程按照约定的顺序 信号量 初始化：sem_init p操作：申请资源sem_wait v操作: 释放资源sem_post 互斥：多个线程执行时只能有一个线程来访问临界资源 互斥锁 初始化：pthread...
Linux C 进程间的通信——无名管道、有名管道、信号
qq_53612102的博客
09-11 851
早期进程间的通信——有名管道、无名管道、信号
趣味算法------试用 6 和 9 组成的最大数字
markingyi的博客
08-26 584
给出一个数字，反转其中一位使数字最大化，递归求解。
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 417
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3258
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1295
分两种情况，一种是节点 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。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4534
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
趣味算法------猴子吃桃(循环，递归双重解法)
markingyi的博客
08-26 494
猴子吃桃问题，已知结果求初始值，分别使用循环和递归两种方式解决。
精选算法编程题
A18937260063的博客
08-30 1609
数组编程
[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
最新发布
Y-puyu 的博客
08-31 342
【代码】[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
冒泡排序算法
m0_74051652的博客
08-28 1384
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
字节跳动（社招）三面算法原题
宫水三叶的刷题日记
08-29 1716
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值