Linux下C语言进程通讯编程

一、基础代码API使用例程：

#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
/*************基本的函数API********************
共享内存函数API
int shmget(key_t key, int size, int flag)
key:
    共享内存的键值，多个进程可以通过它访问同一个共享内存。常用特殊值:IPC_PRIVATE,创建当前进程的私有共享内存
size:
    指定创建共享内存的大小
flag:
    操作权限
char * shmat(int shm_id, const void * addr, int flag)
shm_id:
    要映射的共享内存标识符
addr:
    指定在调用进程中映射共享内存的地址。通常取值为0，表示由系统自动分配地址。
flag:
    设置共享内存的操作权限。若取值为0，表示可对共享内存进行读写操作。
int shmctl(int shm_id, int cmd, struct shmid_ds * buf)
shm_id:
    共享内存标识符
cmd:
    指定索要进行的操作:IPC_STAT IPC_SET IPC_RMID SHM_LOCK SHM_UNLOCK
buf:
    结构体型指针
int shmdt(const void * addr)
**********************************************/
#define Test_pipe 0
#define Test_Shmget 0
#define Test_AT_w 0
#define Test_AT_r 0
#define Test_DT 1
int main(int argc, char *argv[])
{
#if Test_pipe
    int x,fd[2];
    char buf[30],s[30];
    pipe(fd);
    x = fork();
    if(0 == x)
    {
        sprintf(buf,"This is an pipe!");
        write(fd[1],buf,30);
        exit(0);
    }
    else
    {
        wait(0);
        read(fd[0],s,30);
        printf("read: %s\n",s);
    }
#endif

#if Test_Shmget
    int shm_id;
    shm_id = shmget(IPC_PRIVATE,4096,0666);
    if(shm_id < 0)
    {
        perror("shmget id < 0");
        exit(0);
    }
    printf("成功建立共享内存区域: %d\n",shm_id);
    system("ipcs -m");
#endif

#if Test_AT_w
    int shm_id;
    char *shm_buf;
    shm_id = atoi(argv[1]);
    shm_buf = shmat(shm_id,0,0);
    printf("写如数据到共享内存:\n");
    sprintf(shm_buf,"对共享内存的读写操作！");
    printf("%s\n",shm_buf);
#endif

#if Test_AT_r
        int shm_id;
        char *shm_buf,str;
        shm_id = atoi(argv[1]);
        shm_buf = shmat(shm_id,0,0);
        printf("写如数据到共享内存:\n");
        sprintf(str,shm_buf);
        printf("%s\n",str);
    system("ipcs -m");
#endif

#if Test_DT
        int shm_id;
        char *shm_buf;
        shm_id = atoi(argv[1]);
        shm_buf = shmat(shm_id,0,0);
    shmdt(shm_buf);
    shmctl(shm_id,IPC_RMID,NULL);
    system("ipcs -m");
#endif
}

二、接口详细介绍

三、基础实例

1）IPC通讯中共享内存参看代码：

Client端代码client.c（gcc client.c -lm -o client） 

shmget函数得到的共享内存的大小有参数确定，参数的单位是Byte！

同样的shmget参数的0666代表的内容是，共享内存空间的可读可写性！

使用ftok函数获取的key_t key的作用在于生成一个文件节点引索，这样才能够连接两个进程让他们以这个引索值作为标识ID！

shmdt函数用来删除释放掉创建的共享内存空间！

shmat函数用来映射已经创建好的虚拟内存空间地址！返回值为两个进程进行操作的共享内存起始地址！

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

#define random(x) (rand()%x)
#define PI 3.1415926

#define Width 20
#define Height 20

int main(int argc,char *argv[])
{
        key_t key = 0;
        int shmid = 0;
        setbuf(stdout,NULL);
        printf("Begin to Create the shared-mem...\n");
        key = ftok(".",2); // Get the only IPC ID:inode'num + 1
        if(key<0)
        {       
                perror("ftok");
                return -1;
        }
        printf("key=%d\n",key);
        sleep(1);
        printf("...\n");
        printf("%d\n",IPC_CREAT);
        shmid = shmget(key,100,IPC_EXCL | IPC_CREAT | 0666); // Get shared mem:IPC_ID_key Mem_size
        if(shmid<0)
        {
                perror("shmget");
                return -2;
        }
        char * shared_mem_addr = shmat(shmid,NULL,0); // mapping the mem_addr to the addr of the Process
        printf("...\n");

        sleep(2); // waitting for setup the mem

        printf("The shared-mem create sucessfully!\n");
        printf("Begin to insert the data into shared-mem!\n");
        int i=0;
        while(i<Width*Height)
        {
                *(shared_mem_addr+i) = 200*sin((double)i*PI/180.0);// random(255)+255;
                usleep(100);
                printf(".");
                i++;
        }
        printf("\nThe data insert finish!\n");
        shmdt(shared_mem_addr);
        return 0;
}

Server端代码server.c（gcc server.c -o server）

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

#define Width 20
#define Height 20

int main(int argc,char *argv[])
{
        key_t key = 0;
        int shmid = 0;
        key = ftok(".",2); // Get the only IPC ID:inode'num + 1
        if(key<0)
        {
                perror("ftok");
                return -1;
        }
        shmid = shmget(key,100,IPC_CREAT | 0666); // Get shared mem:IPC_ID_key Mem_size
        if(shmid<0)
        {
                perror("shmget");
                return -2;
        }
        char * shared_mem_addr = shmat(shmid,NULL,0); // mapping the mem_addr to the addr of the Process

        sleep(2);

        int i=0;
        while(i<Width*Height)
        {
                printf("The image data:%d\n",*(shared_mem_addr+i));
                usleep(100);
                i++;
        }
        shmdt(shared_mem_addr);
        sleep(1);
        shmctl(shmid,IPC_RMID,NULL);
        return 0;
}

首先运行Clent端，然后再运行Server端即可！

2）Python与C语言共享内存实例

python内存共享：

from ctypes import *  
import numpy as np
import codecs
import datetime

SHM_SIZE = 1024*1024*20 # 20MBytes
SHM_KEY = 123559  

OUTFILE="Shared.PNG"  
try:  
    rt = CDLL('librt.so')  
except:  
    rt = CDLL('librt.so.1')

shmget = rt.shmget
shmget.argtypes = [c_int, c_size_t, c_int]  
shmget.restype = c_int  
shmat = rt.shmat  
shmat.argtypes = [c_int, POINTER(c_void_p), c_int]  
shmat.restype = c_void_p  

shmid = shmget(SHM_KEY, SHM_SIZE, 0o666)

if shmid < 0:  
    print ("System not infected")  
else:
    addr = shmat(shmid, None, 0)  
    f=open(OUTFILE, 'wb')
    begin_time = datetime.datetime.now()
    DataLength = int.from_bytes(string_at(addr,4), byteorder='little', signed=True)   #这里数据文件是小端int16类型
    ImgData = string_at(addr+4,DataLength)
    end_time = datetime.datetime.now()
    print(DataLength, ' Bytes')
    print('Type:',type(ImgData),' Bytes:', len(ImgData))
    f.write(ImgData)
    f.close()  
#print ("Dumped %d bytes in %s" % (SHM_SIZE, OUTFILE))
print("Success!",end_time-begin_time)

C Transform：

#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>

#define SHAERD_MEM_SIZE 20 * 1024 * 1024 // 20MBytes

char mem_free(void *ptr);
time_t get_timestamp_ms(void);
char *file_read(unsigned int *file_bytes, char *file_name);

int main(int argc, char *argv[])
{
    int id = 0;
    size_t offset = 0;
    char *data = NULL;
    char *ImgData = NULL;
    unsigned int file_bytes = 0;
    time_t start_time, end_time;   
    if (argc < 2)
    {
        printf("args too less\n");
        return 0;
    }
    
    id = shmget(123559, SHAERD_MEM_SIZE, IPC_CREAT | 0777);
    if (id < 0)
    {
        printf("get id failed\n");
        return 0;
    }
    
    data = shmat(id, NULL, 0);
    if (data == NULL)
    {
        printf("shamt failed\n");
        return 0;
    }

    ImgData = file_read(&file_bytes, argv[1]);
    offset = sizeof(unsigned int);
    printf("Size of unsigned long:%d\n", offset);
    printf("Size of Image File:%d\n", file_bytes);
    start_time = get_timestamp_ms();
    memcpy(data, &file_bytes, sizeof(unsigned int));
    memcpy(data + offset, ImgData, file_bytes);
    end_time = get_timestamp_ms();

    printf("Time Cost:%d\n", end_time - start_time);

    mem_free(ImgData);

    return 0;
}

char *file_read(unsigned int *file_bytes, char *file_name)
{
  int file_size;
  FILE *fd = NULL;
  char *file_data = NULL;
  fd = fopen(file_name, "rw");
  if(fd < 0)
  {
    printf("File open failed...\n");
    return NULL;
  }
  fseek(fd, 0, SEEK_END);
  file_size = ftell (fd);
  file_data = malloc(sizeof(char)*file_size);
  if(file_data == NULL)
  {
    printf("Malloc failed...\n");
    return NULL;
  }
  fseek(fd, 0, SEEK_SET);
  *file_bytes = fread(file_data,sizeof(char),file_size,fd);
  fclose(fd);
  return file_data;
}

time_t get_timestamp_ms(void)
{
  time_t timestamp_ms = 0;
  struct timeval tv;
  
  gettimeofday(&tv,NULL);
  timestamp_ms = tv.tv_sec * 1000 + tv.tv_usec / 1000;
  return timestamp_ms;
}

char mem_free(void *ptr)
{
  if(NULL != ptr)
  {
    free(ptr);
    return 0;
  }
  printf("Memory is Empty...\n");
  return -1;
}

python-c指针传递

import os
import sys
import time
import ctypes
from ctypes import *
from ctypes import cdll

BUFF_SIZE = 6*1024*1024

class POINT(Structure): # 定义了一个类，类当中的基本成员变量包括了x、y, 相当于C语言中的 struct POINT{int x;inty};
    _fields_ = [("x", c_int),("y", c_int),("addr", POINTER(c_uint8))]

DataPoint = (c_uint8 * 10)() # 定义一个大小为10指针实例作为缓存
DataPoint[3] = 22

point = POINT(10, 20, DataPoint) # 定义个类对象Obj, 相当于 struct POINT point={10,20};
print('Line', sys._getframe().f_lineno, ':', point.x, point.y, point.addr[3])

point = POINT(y=5) # 定义个类对象Obj, 相当于 struct POINT point={,20};
print('Line', sys._getframe().f_lineno, ':', point.x, point.y)


TenPointsArrayType = POINT * 3 # 重定义了一个POINT数组类型，相当于C语言中的 #define TenPointsArrayType POINT*3
arr = TenPointsArrayType()
for pt in arr:
    print(pt.x, pt.y, pt.addr)

p = os.getcwd() + '/libfunc.so' # 获取当前的动态库的绝对路径位置
f = cdll.LoadLibrary(p) # 使用LoadLibrary接口加载C语言动态库
function = f.py_point_address # 从当前库当中取得clib中的函数py_point_address，并重命名为function
function.argtypes = [POINTER(c_byte)] # 设置当前函数的输入参数

i = ctypes.c_int(42) # 定义一个整数类型的变量，变量初始值为 42，相当于C语言中的 int i=42;
pi = ctypes.pointer(i) # 通过使用pointer接口获取，相当于C语言中的 int *pi = &i;
print('Line', sys._getframe().f_lineno, ':', pi.contents) # 查看指针变量的信息
print('Line', sys._getframe().f_lineno, ':', pi[0]) # 查看指针所指向的内容，相当于C语言中的 *pi;

a = (c_byte * BUFF_SIZE)() # 定义一个大小为BUFF_SIZE指针实例作为缓存
# cast(a, POINTER(c_uint8)) # 函数可以将一个指针实例强制转换为另一种 ctypes 类型
print('Line', sys._getframe().f_lineno, ':', a)
print('Line', sys._getframe().f_lineno, ':', type(a))
time_start = time.time()
function(a) # 执行function函数并传入a地址参数
time_end = time.time()

for i in range(10):
    print(a[i])

print('Line', sys._getframe().f_lineno, ':', 'TimeCost:', (time_end - time_start)*1000, 'ms') # 记录当前函数调用消耗的时间

data = ctypes.c_uint8(10) # 定义一个整数类型的变量，变量初始值为 10，相当于C语言中的 char data=42;
data_addr = ctypes.byref(data, 0) # 通过使用byref接口获取地址，相当于C语言中的 char *data_addr = &data; byref(obj, offset) 对应于这段 C 代码:(((char *)&obj) + offset)
print('Line', sys._getframe().f_lineno, ':', type(data))
print('Line', sys._getframe().f_lineno, ':', type(data_addr))

value = 'hello world'  # 定义一个字符串变量
address = id(value)  # 获取value的地址，赋给address
get_value = ctypes.cast(address, ctypes.py_object).value  # 读取地址中的变量
print('Line', sys._getframe().f_lineno, ':', address, get_value) # 

res = f.func(99) # 普通函数调用
print('Line', sys._getframe().f_lineno, ':', res)

C：

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

#define BUFF_SIZE 6*1024*1024

/* func.c */
int func(int a)
{
        return a*a;
}

void cycle_calc(int b)
{
    int count = 100;
    while(count--){
        b*=2;
        printf("%d - %d\n", count, b);
    }
}

unsigned char * c_point_address(void)
{
    unsigned char *Img = malloc(sizeof(unsigned char)*1000);
    printf("C-Address:%d\n", Img);
    memset(Img, 20, 1000);
    return Img;
}

int py_point_address(unsigned char * Addr)
{
    unsigned char *Img = malloc(sizeof(unsigned char)*BUFF_SIZE);
    // printf("C-Address:%x\n", Img);
    // printf("Python-Address:%x\n", Addr);
    memset(Img, 20, BUFF_SIZE);
    memcpy((unsigned char * )Addr, Img, BUFF_SIZE);
    return 1;
}

shell compile：

#!/bin/bash
gcc -fPIC -shared function.c -o libfunc.so
python3 MemoryTest.py

 IPC通信之-管道PIPE

Reference：

https://www.cnblogs.com/mq0036/p/8492621.html

https://www.cnblogs.com/dzzy/p/9376588.html

参看IPC通讯介绍：https://www.cnblogs.com/CheeseZH/p/5264465.html