Linux进程间通信

已于 2023-07-24 09:12:05 修改
阅读量1.7k 收藏 18
点赞数 4
分类专栏： Linux 文章标签： linux
于 2022-09-13 16:37:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54076783/article/details/126753090
版权

目录

进程间通信的目的

进程间通信的几种方式

无名管道

命名管道

创建键值函数ftok()

消息队列

创建或引用一个消息队列msgget()

向消息队列中添加消息msgsnd()

从消息队列中读取消息msgrcv()

控制消息队列msgctl()

共享内存

创建或引用一个共享内存shmget()

将共享内存链接到当前进程的地址空间shmat()

断开共享内存与当前进程的地址空间的链接shmdt()

控制共享内存shmc

管道、消息队列、共享内存的区别

信号

向某个进程发送信号函数kill()

信号接收函数signal()

高级信号发送函数sigqueue(),比kill()在发射信号时能携带更多信息

高级信号接收函数sigaction()，比signal()在接收信号时能获取更多信息

信号量

 创建一个信号量集semget()

控制信号量集或获取信号量的信息semctl()

信号量控制共享资源的操作，即PV操作semop()

进程间通信的目的

  • 数据传输:一个进程需要将它的数据发送给另一个进程
  • 资源共享:多个进程之间共享同样的资源
  • 通知事件:一个进程需要向另一个或一组进程发送消息，通知它发生了某种事件。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如 Debug进程)，此时控制进程希望能够拦截另 一个进程的所有陷入和异常，并能够及时知道它的状态改变

进程间通信的几种方式

无名管道

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

int main()
{
    pid_t pid;
    int fd[2];
    char readBuf[128];

    if(pipe(fd) < 0){
        perror("pipe");
        exit(-1);
    }

    pid = vfork();

    if(pid == 0){
        printf("this is child process\n");
        close(fd[0]);
        write(fd[1],"my name is child process,haozige handsome",128);
        printf("child process is done\n");
        exit(0);
    
    }else if(pid > 0){
        printf("this is father process\n");
        wait(NULL);
        close(fd[1]);
        read(fd[0],readBuf,128);
        printf("from child process content is %s\n",readBuf);
        printf("father process is done\n");

    }else{
        printf("fork is fail\n");
        perror("fork");
        exit(-1);
    }

    return 0;
}

命名管道

与无名管道不同的是，命名管道可以在没有关系的两个进程间进行通信

由于read()函数在读不到数据时会阻塞，因此我们在读数据的进程创建命名管道，并阻塞等待写数据的进程向命名管道写入数据 ，在创建命名管道时，给管道的权限建议是0600，即可读可写可执行

读数据进程

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc,char *argv[])
{
    if(argc < 2){
        printf("missing paramiter -> FIFO");
        exit(-1);
    }

    char readBuf[128];
    int readSize = 0;

    if(mkfifo(argv[1],0600) < 0){
        perror("mkfifo");
        exit(-1);
    }

    int fd = open(argv[1],O_RDONLY);
    if(fd < 0){
        perror("open");
        exit(-1);
    }

    while(1){
        memset(readBuf,'\0',128);
        readSize = read(fd,readBuf,128);
        printf("read data from FIFO %s, content is %s\n",argv[1],readBuf);
    }
    close(fd);

    return 0;
}

命名管道是类似创建文件的形式创建的  

写数据进程

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main(int argc,char *argv[])
{
    if(argc < 2){
        printf("missing paramiter -> FIFO");
        exit(-1);
    }

    char Msg[128] = "from write FIFO send jiangxiaoya is pigHead";

    int fd = open(argv[1],O_WRONLY);

    while(1){
        write(fd,Msg,strlen(Msg));
        sleep(1);
    }
    close(fd);

    return 0;
}

 当写数据进程启动后，读数据进程不再阻塞，开始读取命名管道的数据

命名管道的应用：

  • shell命令使用FIFO将数据从一条管道传送到另一条时，无需创建中间临时文件。
  • 客户进程-服务器进程应用程中，FIFO用作汇聚点，在客户进程和服务器进程二者之间传递数据。

创建键值函数ftok()

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>

int main(int argc,char *argv[])
{
    if(argc < 2){
        printf("missing parameter -> keyfile\n");
        exit(-1);
    }
    key_t key;
    key = ftok(argv[1],'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }else{
        printf("key value is %d\n",key);
    }

    key = ftok(argv[1],159);

    if(key == -1){
        perror("ftok");
        exit(-1);
    }else{
        printf("key value is %d\n",key);
    }

    return 0;
}

消息队列

消息队列是一个存储信息的链表，全双工通信，进程终止后，数据不会丢式 

创建或引用一个消息队列msgget()

向消息队列中添加消息msgsnd()

从消息队列中读取消息msgrcv()

控制消息队列msgctl()

 

 向消息队列添加各种消息的sendMsg进程

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

struct Msgbuf
{
    long mtype;
    char mtext[128];
};

int main(int argc,char *argv[])
{
    key_t key;
    key = ftok("./keyfile.txt",'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }

    int msgID = msgget(key,IPC_CREAT|0777);

    if(msgID == -1){
        perror("msgget");
        exit(-1);
    }

    struct Msgbuf sendMsg = {
        130,
        "this is sendMsg process"
    };

    struct Msgbuf sendMsg1 = {
        181,
        "haozige handsome"
    };

    struct Msgbuf sendMsg2 = {
        166,
        "jiangxiaoya pigHand"
    };

	msgsnd(msgID,&sendMsg,strlen(sendMsg.mtext),0);
    msgsnd(msgID,&sendMsg1,strlen(sendMsg1.mtext),0);
    msgsnd(msgID,&sendMsg2,strlen(sendMsg2.mtext),0);

    struct Msgbuf receive;
    memset(&receive,0,sizeof(receive));
    msgrcv(msgID,&receive,sizeof(receive.mtext),2349,0);

    printf("this is sendMsg process,receive msg from messageQueue,content is %s\n",receive.mtext);

    //msgctl(msgID,IPC_RMID,NULL);

    return 0;
}

根据消息字段读取消息队列中的消息的receive进程，要使用同一个键值才能访问到同一个消息队列 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <unistd.h>

struct Msgbuf
{
    long mtype;
    char mtext[128];
};

int main(int argc,char *argv[])
{
    key_t key;
    key = ftok("./keyfile.txt",'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }

    int msgID = msgget(key,IPC_CREAT|0777);

    if(msgID == -1){
        perror("msgget");
        exit(-1);
    }

    struct Msgbuf sendMsg = {
        2349,
        "this is receiveMsg process"
    };

    msgsnd(msgID,&sendMsg,strlen(sendMsg.mtext),0);

    struct Msgbuf receive;
    struct Msgbuf receive1;
    struct Msgbuf receive2;
	memset(&receive,0,sizeof(receive));
    memset(&receive1,0,sizeof(receive1));
    memset(&receive2,0,sizeof(receive2));

    msgrcv(msgID,&receive,sizeof(receive.mtext),130,0);
    msgrcv(msgID,&receive1,sizeof(receive1.mtext),181,0);
    msgrcv(msgID,&receive2,sizeof(receive2.mtext),166,0);

    printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive.mtext);
    sleep(5);
    printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive1.mtext);
    sleep(5);
    printf("this is receiveMsg process,receive msg from messageQueue,content is %s\n",receive2.mtext);

    msgctl(msgID,IPC_RMID,NULL);

    return 0;
}

 

共享内存

创建或引用一个共享内存shmget()

将共享内存链接到当前进程的地址空间shmat()

断开共享内存与当前进程的地址空间的链接shmdt()

控制共享内存shmctl

 创建一块共享内存，writeShm进程每隔1秒向共享内存写入一个字母，readShm进程每隔一秒从共享内存读取一个字母，当从共享内存连续10s读不到数据后，会删除该共享内存

my_writeShm进程：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>


int main(int argc,char *argv[])
{
    key_t key = ftok(".",'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }

    int shmID = shmget(key,1024*4,IPC_CREAT|0666);

    if(shmID == -1){
        perror("shmget");
        exit(-1);
    }

    char *tmp = (char *)shmat(shmID,NULL,0);
    memset(tmp,'\0',1024*4);
    char *str = "abcdefghijklmnopqrstuvwxyz";

    while(*str != '\0'){
        sprintf(tmp,"%c",*str);
        sleep(1);
        *str++;
    }
    memset(tmp,'\0',1024*4);

    shmdt(tmp);

    //shmctl(shmID,IPC_RMID,NULL);

    return 0;
}

my_readShm进程： 

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <string.h>
#include <sys/shm.h>


int main(int argc,char *argv[])
{
    key_t key = ftok(".",'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }

    int shmID = shmget(key,1024*4,IPC_CREAT|0666);

    if(shmID == -1){
        perror("shmget");
        exit(-1);
    }

    char *tmp = (char *)shmat(shmID,NULL,0);
    while(1){
        printf("shm content is %s\n",tmp);
        sleep(1);

        if(strlen(tmp) == 0){
            sleep(10);
            if(strlen(tmp) == 0){
                break;
            }
        }
    }
    shmdt(tmp);

    shmctl(shmID,IPC_RMID,NULL);

    return 0;
}

管道、消息队列、共享内存的区别

将三者进程间的通信看作纸条上的通信

  • 管道：一方拿走这个纸条进行写内容，另一方只能等对方写完这个纸条才能拿走这个纸条进行读内容，半双工通信
  • 消息队列：在一个纸箱存放着多张纸条，纸条上有号码标注，每一张纸条都是独一无二，一方拿走了一张纸条进行写内容或读内容，同时另一方也拿走了一张纸条进行写内容或读内容，操作完后会把纸条放回纸箱中，全双工通信
  • 共享内存：双方同时拿着纸条，一方在纸条写内容，另一方实时在纸条上读内容（实时性）

信号

向某个进程发送信号函数kill()

信号接收函数signal()

使用signal()函数实现Linux定时器，每隔2s输出一个字符串，使用kill()关闭这个定时器

signal()进程

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

static int i = 0;

void time_handle(int signum)
{
    i++;
    if(i == 2000){
        printf("2s to hello haozige,my process pid is %d\n",getpid());
        i = 0;
    }
}

int main()
{

    struct itimerval tmp;

    tmp.it_value.tv_sec = 0;
    tmp.it_value.tv_usec = 500*1000;

    tmp.it_interval.tv_sec = 0;
    tmp.it_interval.tv_usec = 500;

    if(setitimer(ITIMER_REAL,&tmp,NULL) == -1){
        perror("setitimer");
        exit(-1);
    }//SIGALRM

    signal(SIGALRM,time_handle);
    while(1);
    return 0;
}

相关结构体

 

 

 kill()进程

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>


int main(int argc,char *argv[])
{
    if(argc < 2){
        printf("missing parameter -> process pid\n");
        exit(-1);
    }

    pid_t pid = atoi(argv[1]);

    kill(pid,SIGINT);
    sleep(1);
    printf("pid is %d process is done!\n",pid);
    return 0;
}

高级信号发送函数sigqueue(),比kill()在发射信号时能携带更多信息

 

高级信号接收函数sigaction()，比signal()在接收信号时能获取更多信息

sigset_t sa_mask:

 int sa_flags:

 siginfo_t 结构：保存的其他信息

进程A使用sigqueue向进程B发送信号和携带信息：年龄21和年龄20两个整型数，进程B收到该信号后进行处理

进程A：sigqueue()

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>

int main(int argc,char *argv[])
{
    if(argc < 2){
        printf("missing parameter -> process pid\n");
        exit(-1);
    }

    pid_t pid = atoi(argv[1]);

    int tmp = 0;
    union sigval msg;
    msg.sival_int = 21;

    while(1){
        sigqueue(pid,SIGUSR1,msg);
        tmp++;
        if(tmp == 5){
            msg.sival_int = 19;
        }
        if(tmp == 10){
            kill(pid,SIGINT);
            break;
        }
        sleep(1);
    }
    return 0;
}

进程B：sigaction() 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

static int i = 0;

void time_handle(int signum,siginfo_t *tmp,void *context)
{

    if(context != NULL){
        printf("msg from pid %d process\n",tmp->si_pid);
        printf("age is %d\n",tmp->si_value.sival_int);
        printf("age is %d\n",tmp->si_int);
    }else{
        printf("Segment errors may occur\n");
        printf("1%s",(char *)context);
    }
}

int main()
{
    struct sigaction sigMsg;
    printf("my process pid is %d\n",getpid());

    sigMsg.sa_flags = SA_SIGINFO;
    sigMsg.sa_sigaction = time_handle;

    sigemptyset(&sigMsg.sa_mask);//初始化信号集，清空该信号集里的所有信号

    sigaction(SIGUSR1,&sigMsg,NULL);

    while(1);
    return 0;
}

信号量

 信号量并非单个非负值，必须定义为多个信号量的集合，称为信号量集

 创建一个信号量集semget()

控制信号量集或获取信号量的信息semctl()

 

 

信号量控制共享资源的操作，即PV操作semop()

 

 信号量保证子进程先运行，父进程后运行，同理子进程先获得临界资源，父进程后获得临界资源

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

//semctl()参数4,保存信号量的信息或者设置信号量的信息
union semun {
    int val;    
    struct semid_ds *buf;    
    unsigned short  *array;  
    struct seminfo  *__buf;  
};

//p操作
void handle_P(int id)
{
    struct sembuf pBuf;
    pBuf.sem_num = 0;
    pBuf.sem_op = -1;
    pBuf.sem_flg = SEM_UNDO;
    if(semop(id,&pBuf,1) < 0){
        perror("semop");
        exit(-1);
    }
}

//v操作
void handle_V(int id)
{
    struct sembuf vBuf;
    vBuf.sem_num = 0;
    vBuf.sem_op = 1;
    vBuf.sem_flg = SEM_UNDO;
    if(semop(id,&vBuf,1) < 0){
        perror("semop");
        exit(-1);
    }
}

int main(int argc,char *argv[])
{
    key_t key = ftok(".",'z');

    if(key == -1){
        perror("ftok");
        exit(-1);
    }

    int semID = semget(key,1,IPC_CREAT|0666);

    if(semID < 0){
        perror("semget");
        exit(-1);
    }

    union semun tmp;
    tmp.val = 0; //信号量初始值

    if(semctl(semID,0,SETVAL,tmp) < 0){
        perror("semctl");
        exit(-1);
    }
    pid_t pid = fork();
    if(pid > 0){
		//如果父进程先运行，由于信号量初始值为0，执行p操作后父进程进入阻塞状态
        printf("father process is wait\n");
        handle_P(semID);//p操作
        printf("child process lets father process cancel wait\n");

        semctl(semID,0,IPC_RMID);

    }else if(pid == 0){
		//子进程运行
        printf("child process function\n");
		//5s后执行v操作唤醒父进程
        printf("wake up the father process after 5s\n");
        int i;
        for(i=1;i<6;i++){
            sleep(1);
            printf("%d\n",i);
        }
        handle_V(semID);//v操作
   
   }else{
        perror("fork");
        exit(-1);
    }

    return 0;
}

haozigegie
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信之共享内存
07-26
本文主要介绍Linux进程间通信中共享内存的知识，感兴趣的朋友可以看看。
linux进程间的7种通信方式全解析及代码示例
q472599451的专栏
09-04 1088
管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。
Linux进程间通信方法和代码示例
zhaoyqcsdn的博客
01-28 327
Linux进程间通信（IPC, Inter-Process Communication）包括了多种不同的技术，例如管道（pipe）、信号（signal）、共享内存（shared memory）、消息队列（message queues）、信号量（semaphores）以及套接字（sockets）等。管道是最基本的IPC机制之一，这里指匿名管道，允许一个进程和另一个进程之间的单向数据流。套接字允许在同一台计算机上的进程或不同计算机上的进程之间进行通信。共享内存允许两个或两个以上的进程共享一个给定的存储区。
linux c 进程间通信 信号灯 程序源码
03-01
linux c 进程间通信 信号灯 程序源码
linux 进程间通信及多线程操作源码
02-27
全双工邮箱通讯，两个程序分别同过共享内存(邮箱)相互传输数据， 分别都有一个读写线程，读写个自通讯数据区域，一个读线程对应另一个进程的写线程；
进程间通信源码
10-08
进程间通信的VC++源码实例集，邮槽、匿名管道等。
Linux —— 进程间通信
M的博客
07-23 5501
进程间通信方式的介绍：管道通信、system V通信......
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
Linux-进程间通信
AI_ELF的博客
08-23 6117
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux之进程间通信
cls的博客
03-22 1778
共享内存在内核中申请的基本单位是页，这个页叫做内存页，这个内存页叫做4KB。如果我申请4097个字节，内核会向上取整，给你4096byte*2（多要了一个就得多申请一页，因为没有4097）。但是我们实际看到的并不是4096*2，而是4097，这又是怎么回事呢？如果我向OS要了10个字节，OS只给了9个，我就认为是错的，因为很容易发生越界，OS就有问题。
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 5664
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
Linux进程间通信–使用信号
01-11
一、什么是信号 用过Windows的我们都知道，当我们无法正常结束一个程序时，可以用任务管理器强制结束这个进程，但这其实是怎么实现的呢？同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些行动。通常信号是由一个错误产生的。但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，常用的信
嵌入式Linux进程与进程间通信.zip
09-06
嵌入式软件开发，C语言源码。
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
linux-linux进程间通信方式汇总.zip
02-26
linux linux_linux进程间通信方式汇总
Linux 进程间通信
12-16
Linux进程间的通信实现方式，比如管道、消息队列等
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 498
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
linux18：进程等待
m0_73919066的博客
04-20 1081
1：子进程创建的目的是要完成父进程指派的某个任务，当子进程运行完毕退出时，父进程需要通过进程等待的方式，回收子进程资源，获取子进程退出信息（子进程有无异常？没有异常结果是否正确？检查退出码查看错误原因）2：父进程如果一直不回收，就可能造成子进程‘僵尸进程’的问题，子进程一直得不到父进程的回收，进而造成内存泄漏。3：子进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力杀死一个已经死去的进程。只能通过进程等待将他进行回收。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值