精华内容
下载资源
问答
  • 3、该内存库只允许一个模块写入, 但可多个模块读取, 但需要各个读取模块没有任何相互干扰, 比如一个模块可能读取的速度较慢, 一个读取的速度较快 4、该内存库需要具有一定的数据缓冲, 实际的应用上, ...

    首先,看看老大给我的任务:实现一个模块间的内存管理库, 实现以下功能

    1、该内存库通讯的数据量不确定, 最大5Mbit/s 
    2、该内存库用于模块间的数据交互
    3、该内存库只允许一个模块写入, 但可多个模块读取, 但需要各个读取模块没有任何相互干扰, 比如一个模块可能读取的速度较慢, 一个读取的速度较快
    4、该内存库需要具有一定的数据缓冲, 实际的应用上, 用于视频帧数据的交互,  
    5、封装成动态库
    我拿到题目后,第一想法是,这很简单,两模块虽然不能同时写,同时读还是很容易的,接下来就傻了。。。老大要求的是实现同时读和写,并且多个读不影响。

    遇到的问题:

    1,进程间最好用的通信方式是共享内存,内存大且操作容易。

    2,数据量不确定是写入时的文件大小不确定,那么怎么来回改变共享内存大小。(可变数组行不通)

    3,多个进程读,多次创建挂载共享内存,销毁时会出现问题。

    4,读写不同步,写完之后读不是想要的结果。

    5,重复性的问题,避免重复读。

    下面详细介绍我的痛苦历程:

    首先,我们来说说共享内存,共享内存是进程间通信的一种很好用的方式,内存足够大,创建销毁简单,在前面已经介绍过了,关于创建的函数见链接 http://blog.csdn.net/agoni_xiao/article/details/77165428

    接下来,处理文件大小不稳定的情况,用get_blocksize函数,根据文件大小改变块的大小及个数。


    我本来想用可变数组后来发现每次都读不完整,是因为可变数组是从地址访问到地址,如果别的程序用到你的地址,就会出现错误。

    然后,想使用缓冲区环形和整型,但如果这样每次都需要开辟的内存是把整个文件写入共享内存,而不是一部分一部分去写,如果写一部分,第一个模块读完并载入新的数据,第二个模块就会读不到之前的数据,或者读到部分数据,所以放弃缓冲区的想法。环形缓冲区和整型缓冲区知识http://www.cnblogs.com/zengzy/p/5139582.html


    对于读写的同步,写在前,读在后,每个块都有一个状态标志block_status,为1时表示该块已写入完成可读,为2时表示已读过。当第一个模块读完第一个块之后,继续读第二个块,当读到第二个块的时候,把第一个块状态置为1,以便后面的模块读取。图见下:


    解决共享内存多次释放问题,是通过共享内存结构体中,保存创建好的信息,在下一块链接时,读取并判断。

    废话少说,直接上代码.

    头文件shm.h:

    #include<stdlib.h>
    #include<sys/shm.h>
    #include<unistd.h>
    #include<string.h>
    #include<time.h>
    #ifndef _SHAREMRY_H_HEADER
    #define _SHAREMRY_H_HEADER
    #define SIZE 1024*1024
    struct share_temp
    {
    	int read_success;
    	int size;
    	int block_status[10];
    	int is_readed[10];
    	int is_empty;
    	char text[SIZE];
    	int shmid_line;
    	void *shm_line;
    };
    
    void* rmapi_create_sharememory();
    //int get_blockcount(int size,int bsize);
    int get_blocksize(int size);
    void init_is_readed(struct share_temp **shared);
    int rmapi_put_frame(void* memory, const char* data, unsigned int data_size);
    int rmapi_get_frame(void* memory,char** data,unsigned int data_size);
    void read_file(int size, struct share_temp **shared,char** filedata);
    void rmapi_destroy_read_sharememory(void* memory);
    void rmapi_destroy_write_sharememory(void* memory);
    
    #endif
    
    读模块readshm.cpp

    #include<iostream>
    #include<stdio.h>
    #include"shm.h"
    
    using namespace std;
    class ReadBlock
    {
    	public:
    		ReadBlock(){}
    		~ReadBlock(){}
    
    		void* creatershm()
    		{
    			shm_line = rmapi_create_sharememory();
    			return shm_line;
    		}
    		//void File_opt();
    		
    	private:
    		//struct share_temp sw;
    		void* shm_line;
    		
    };
    
    int main()
    {
    	ReadBlock rb;
    	int size,shmid_line;
    	
    	//char* fdata = (char*)malloc(size);
    	void* readshm = rb.creatershm();
    	struct share_temp *spq =(struct share_temp *)readshm;
    	size = spq->size;
    	char* fdata = (char*)malloc(size);
    	rmapi_get_frame(readshm, &fdata, size);
        rmapi_destroy_write_sharememory(readshm);
    }
    
    写模块writeshm.cpp

    #include<iostream>
    #include<stdio.h>
    #include"shm.h"
    using namespace std;
    void *rmapi_create_sharememory();
    class WriteBlock
    {
    	public:
    		WriteBlock(){}
    		~WriteBlock(){}
    		
    		void *createwshm()
    		{
    			shm_line = rmapi_create_sharememory();
    			return shm_line;
    		}
    		
    		
    	private:
    		//struct share_temp sw;
    		void* shm_line;
    		
    };
    
    int main(int argc,char *argv[])
    {
    	WriteBlock wb;
    	int count,size,bsize,shmid_line;
    	
    	FILE *fr;    		
    	fr = fopen(argv[1],"a+");
    	fseek(fr,0,SEEK_END);
    	size = ftell(fr);
    	rewind(fr);
    	
    	void *wshmline = wb.createwshm();
    	struct share_temp* write_shm = (struct share_temp *)wshmline;
    	char* fdata = (char *)malloc(size);
    	fread(fdata,size,1,fr);
    	cout<<"the fread fileinfo is"<<fdata<<endl;
    	
    //	rmapi_put_frame(wshmline, fdata, size);
    	
    	write_shm->size = size;
    	cout<<"the wshmline->size:"<<write_shm->size<<endl;
    	rmapi_put_frame(wshmline,fdata,size);
    	rmapi_destroy_write_sharememory(wshmline);
    	fclose(fr);
    }
    
    方法库sharemrylib.cpp
    #include<iostream>
    #include<stdlib.h>
    #include<unistd.h>
    #include<stdio.h>
    #include"shm.h"
    using namespace std;
    void init_is_readed(void **memory)
    {
    	void *rst = *memory;
    	struct share_temp *shared = (struct share_temp *)rst;
    	int rf = 0;
    	for(rf;rf<10;rf++)
    	{
    		shared->is_readed[rf] = 0;
    		cout<<"init_is_readed"<<rf<<"is ok"<<endl;
    	}
    	shared = NULL;
    
    }
    int get_blocksize(int size)
    {
    	int bs;
    	if(size > 1024*1024)
    	{
    		bs = 1024*1024;
    	}
    	if(size > 1024*512 && size < 1024*1024)
    	{
    		bs = 1024*8;
    	}
    	if(size >1024 && size < 1024*512)
    	{
    		bs = 1024;
    	}
    	if(size < 1024)
    	{
    		bs = 1024;
    	}
    	return bs;
    }
    int get_blockcount(int size,int bsize)
    {	
    	int count = size/bsize;
    	cout<<"the block count is:"<<count<<endl;
    	return count;
    }
    void read_file(int size, struct share_temp **shared,char** filedata)
    {	
    	char* readdata = *filedata;
    	struct share_temp *pos;
    	char *readp,*tpbuf;
    	int count,remind;
    	int di = 0;
    	pos = *shared;
    	readp = pos->text;
    	int bsize = get_blocksize(size);
    	cout<<"the bsize is "<<bsize<<endl;
    	count = get_blockcount(size,bsize);
    	cout<<"the count is"<<count<<endl;
    	tpbuf = (char*)malloc(bsize);
    	while(di <= count)
    	{
    		if(pos->block_status[di] > 0)
    		{
    			switch (pos->is_readed[di])
    			{
    				case 1:
    					sleep(5);
    					//cout<<"the  "<<di<<"  block text info is"<<readp<<endl;
    					memcpy(tpbuf,readp,bsize);
                    
    					cout<<"the  "<<di<<"  block text info is"<<tpbuf<<endl;
    					memcpy(readdata,tpbuf,bsize);
    					memset(tpbuf,0,bsize);
    					pos->is_readed[di] = 2;
    					pos->is_readed[di-1] = 1;
    					readp =readp + bsize;
    					di += 1;
    					break;
    				case 2:
    					cout<<"the"<<di<<"block is readed"<<endl;
    					pos->is_readed[di] = 1;
    					di += 1;
    			}
    		}
    		else
    		{
    			cout<<"wait the "<<di<<"  write info"<<endl;
    			di += 0;
    		}
    	}	
    	cout<<"the di is "<<di<<endl;	
    	if(pos->block_status[di] == 1 && pos->is_readed[di] == 1)
    	{
    		cout<<"the remind info is"<<readp<<endl;
    		pos->is_readed[di] = 2;
    		memcpy(readdata,readp,remind);
    	}
    	pos = NULL;
    	readp = NULL;
    	readdata = NULL;
    }
    
    void* rmapi_create_sharememory()
    {
    	void *shm = NULL;
    	int shmid = shmget((key_t)1342, SIZE, 0666|IPC_CREAT);
    	if(shmid == -1)
    	{		
    		cout<<"shmid failed"<<endl;
    	}
    	shm = shmat(shmid, (void *)0, 0);
    	struct share_temp *shared = (struct share_temp*)shm;
    	shared->shmid_line = shmid;
    	shared->shm_line = shm;
    	//framecount = shmid; 
    	cout<<"memory attach at "<<(int)shm<<endl;
    	if(shm == (void*)-1)
    	{
    		cout<<"shmat failed"<<endl;
    	}
    	return shm;
    }
    
    
    
    int rmapi_put_frame(void* memory, const char* data, unsigned int data_size)
    {
    	
    	struct share_temp* shared = (struct share_temp*)memory;
    	
    	struct share_temp *post = shared;
    	char *dost = post->text;
    	int bsize,count;
    	int ri = 0;
    	if(data_size>1024)
    	{
    	bsize = get_blocksize(data_size);
    	
    	count = data_size / bsize;
    	int remind = (data_size - count * bsize);
    	cout<<"the remind size is:"<<remind<<endl;
    	post->is_empty = 1;
    
    	for(ri;ri<count;ri++)
    	{
    		cout<<"begin write the"<<ri<<"block"<<endl;
    		
    		memcpy(dost,data,bsize);
    		cout<<"block"<<ri<<"the dost is"<<dost<<endl;
    		
    		post->block_status[ri] = 1;
    		post->is_readed[ri] = 1;
    
    		sleep(3);
    		dost = dost + bsize;
    		data = data + bsize;
    		//free(tpbuf);
    	}	
    	memcpy(dost,data,remind);
    	
    	cout<<"the remind info is "<<data<<endl;
    	cout<<"the remind size is "<<remind<<endl;
    	post->block_status[ri] = 1;	
    	post->is_readed[ri] = 1;
    	}
    	else
    	{
    		memcpy(dost,data,data_size);
    		post->block_status[ri] = 1;
    	}
    	post = NULL;
    	dost = NULL;
    }
    
    int rmapi_get_frame(void* memory, char** data, unsigned int data_size)
    {
    	
    	struct share_temp* shared = (struct share_temp*)memory;
    	
    	struct share_temp *post = shared;
    	char* filedata = *data;
    	int running = 1;	
    	while(running)
    	{
    		if(shared->is_empty == 0)
    		{
    			cout<<"have read nothing,the shm is empty"<<endl;
    			sleep(5);
    			continue;
    		}
    		read_file(data_size,&shared,&filedata);
    		
    		running = 0;
    	}
    }
    
    void rmapi_destroy_read_sharememory(void* memory)
    {
    	struct share_temp* shared = (struct share_temp*)memory;
    	int shmid = shared->shmid_line;
    	void *shm = shared->shm_line;
    	
    	if(shmdt(shm) == -1)
    	{
    		cout<<"shmdt failed"<<endl;
    		exit(EXIT_FAILURE);	
    	}
    	cout<<"shmdt success"<<endl;
    	if(shmctl(shmid,IPC_RMID,0) == -1)	
    	{			
    		cout<<"shmctl failed"<<endl;
    		exit(EXIT_FAILURE);	
    	}
    	cout<<"shmctl success"<<endl;
    }
    void rmapi_destroy_write_sharememory(void* memory)
    {
    	struct share_temp* shared = (struct share_temp*)memory;
    	int shmid = shared->shmid_line;
    	void *shm = shared->shm_line;
    	
    	if(shmdt(shm) == -1)
    	{
    		cout<<"shmdt failed"<<endl;
    		exit(EXIT_FAILURE);	
    	}
    	cout<<"shmdt success"<<endl;
    }
    

    makefile文件:

    CPP = g++
    CPPFLAGS = -fpic
    LIB = libsharemry.so
    HPATH = /home/xudong/share_memory/
    LIBPATH = /home/xudong/share_memory/


    edit:sharemry.o libsharemry.so readshm.o writeshm.o readshm readshm2 writeshm 


    readshm:
    $(CPP) -o readshm readshm.cpp -I $(HPATH) -L $(LIBPATH) -lsharemry 


    readshm2:
    $(CPP) -o readshm2 readshm2.cpp -I $(HPATH) -L $(LIBPATH) -lsharemry 
    writeshm:
    $(CPP) -o writeshm writeshm.cpp -I $(HPATH) -L $(LIBPATH) -lsharemry
    libsharemry.so:
    $(CPP) -shared -o $(LIB) sharemrylib.o 

    sharemry.o:
    $(CPP) $(CPPFLAGS) -c sharemrylib.cpp

    以上就是所有的源代码。




    展开全文
  • ),执行后两个或多个读进程可同时读取该文件并在终端打印。 要实现该功能,首先你得了解共享内存的搭建,有四个函数,分别为shmget,shmat,shmdt,shmctl,他们的作用如下: 1、shmget函数 该函数用来创建共享...

    主要功能:读取任意的文件,大小不限(不超过共享内存设置的大小,一般为8k,但可手动重新设置,这已经很大了。),执行后两个或多个读进程可同时读取该文件并在终端打印。

    要实现该功能,首先你得了解共享内存的搭建,有四个函数,分别为shmget,shmat,shmdt,shmctl,他们的作用如下:

    1、shmget函数
    该函数用来创建共享内存,它的原型为:
    [cpp]  view plain  copy
     print ?
    1. int shmget(key_t key, size_t size, int shmflg);  
    第一个参数,与信号量的semget函数一样,程序需要提供一个参数key(非0整数),它有效地为共享内存段命名,shmget函数成功时返回一个与key相关的共享内存标识符(非负整数),用于后续的共享内存函数。调用失败返回-1.

    不相关的进程可以通过该函数的返回值访问同一共享内存,它代表程序可能要使用的某个资源,程序对所有共享内存的访问都是间接的,程序先通过调用shmget函数并提供一个键,再由系统生成一个相应的共享内存标识符(shmget函数的返回值),只有shmget函数才直接使用信号量键,所有其他的信号量函数使用由semget函数返回的信号量标识符。

    第二个参数,size以字节为单位指定需要共享的内存容量

    第三个参数,shmflg是权限标志,它的作用与open函数的mode参数一样,如果要想在key标识的共享内存不存在时,创建它的话,可以与IPC_CREAT做或操作。共享内存的权限标志与文件的读写权限一样,举例来说,0644,它表示允许一个进程创建的共享内存被内存创建者所拥有的进程向共享内存读取和写入数据,同时其他用户创建的进程只能读取共享内存。

    2、shmat函数
    第一次创建完共享内存时,它还不能被任何进程访问,shmat函数的作用就是用来启动对该共享内存的访问,并把共享内存连接到当前进程的地址空间。它的原型如下:
    [cpp]  view plain  copy
     print ?
    1. void *shmat(int shm_id, const void *shm_addr, int shmflg);  
    第一个参数,shm_id是由shmget函数返回的共享内存标识。
    第二个参数,shm_addr指定共享内存连接到当前进程中的地址位置,通常为空,表示让系统来选择共享内存的地址。
    第三个参数,shm_flg是一组标志位,通常为0。

    调用成功时返回一个指向共享内存第一个字节的指针,如果调用失败返回-1.

    3、shmdt函数
    该函数用于将共享内存从当前进程中分离。注意,将共享内存分离并不是删除它,只是使该共享内存对当前进程不再可用。它的原型如下:
    [cpp]  view plain  copy
     print ?
    1. int shmdt(const void *shmaddr);  
    参数shmaddr是shmat函数返回的地址指针,调用成功时返回0,失败时返回-1.

    4、shmctl函数
    与信号量的semctl函数一样,用来控制共享内存,它的原型如下:
    [cpp]  view plain  copy
     print ?
    1. int shmctl(int shm_id, int command, struct shmid_ds *buf);  
    第一个参数,shm_id是shmget函数返回的共享内存标识符。

    第二个参数,command是要采取的操作,它可以取下面的三个值 :
        IPC_STAT:把shmid_ds结构中的数据设置为共享内存的当前关联值,即用共享内存的当前关联值覆盖shmid_ds的值。
        IPC_SET:如果进程有足够的权限,就把共享内存的当前关联值设置为shmid_ds结构中给出的值
        IPC_RMID:删除共享内存段

    第三个参数,buf是一个结构指针,它指向共享内存模式和访问权限的结构。
    shmid_ds结构至少包括以下成员:
    [cpp]  view plain  copy
     print ?
    1. struct shmid_ds  
    2. {  
    3.     uid_t shm_perm.uid;  
    4.     uid_t shm_perm.gid;  
    5.     mode_t shm_perm.mode;  
    6. };  

    具体思路:先写后读,写进程先打开文件,然后往shmemory共享内存内写入文件,读进程直接从共享内存中读文件,并打印出来。

    三个文件:shmwrite.c (写进程) shmread.c(读进程,可以有多个)  sharemry.h(头文件)

    先看头文件sharemry.h:


    定义了flag是否可读的标志,size写入文件的大小,free_status是否最后一个读进程,text是一个可变数组,根据打开的文件大小开辟内存。无论是端还是写端,都必须先挂载到同一共享内存上。

    可变数组:

    text[0]结构

    经常遇到的结构形状如下:

    struct buffer
    {
        int text_len;   //长度
        char text[0];  //起始地址
    };

      在这个结构中,text是一个数组名;但该数组没有元素;该数组的真实地址紧随结构体buffer之后,而这个地址就是结构体后面数据的地址(如果给这个结构体分配的内容大于这个结构体实际大小,后面多余的部分就是这个text的内容);这种声明方法可以巧妙的实现C语言里的数组扩展。


    下图是shmwrite.c写进程源码:


    挂载到共享内存之后,开始读文件并写入共享内存


    写入完成,将程序和共享内存卸载,也即脱离。


    最后是shmread.c:


    接上图


    这里就会用到flag,有两个或多个进程同时读同一个共享内存时,每个读进程都会去挂载这块创建好的共享内存,但是有个隐藏的bug,共享内存是公用的一块,如果每个读进程都去shmctl共享内存的话,会出现错误,类似于内存泄露。所以标志flag保证最后一个读进程退出时才删除共享内存。

    展开全文
  • Linux多个进程或线程同时对一个文件进行操作  Linux多个进程或线程同时对一个文件进行操作,如何解决冲突? 使用flock(锁定文件或解除锁定),简单可行! 先介绍一下flock函数吧 头文件 #...
    Linux下多个进程或线程同时对一个文件进行写操作
      Linux下多个进程或线程同时对一个文件进行写操作,如何解决冲突?

    使用flock(锁定文件或解除锁定),简单可行!
    先介绍一下flock函数吧

    头文件 #include<sys/file.h>
    定义函数 int flock(int fd,int operation);
    函数说明 flock()会依参数operation所指定的方式对参数fd所指的文件做各种锁定或解除锁定的动作。此函数只能锁定整个文件,无法锁定文件的某一区域。
    参数
    operation有下列四种情况:
    LOCK_SH 建立共享锁定。多个进程可同时对同一个文件作共享锁定。
    LOCK_EX 建立互斥锁定。一个文件同时只有一个互斥锁定。
    LOCK_UN 解除文件锁定状态。
    LOCK_NB 无法建立锁定时,此操作可不被阻断,马上返回进程。通常与LOCK_SH或LOCK_EX 做OR(|)组合。
    单一文件无法同时建立共享锁定和互斥锁定,而当使用dup()或fork()时文件描述词不会继承此种锁定。
    返回值 返回0表示成功,若有错误则返回-1,错误代码存于errno。

    上代码!

    #include <sys/file.h> //flock header file
    #include <unistd.h> //ftruncate header file

    FILE *fin;
    //读写打开一个文本文件,允许读和写
    fin = fopen(szFile, "rt+");
    if (!fin)
    {
    cout << "Fail to open the file: " << szFile << endl;
    return;
    }

    //建立排他锁,阻塞方式
    if ( (flock(fileno(fin), LOCK_EX)) < 0 )
    {
    cout << "Fail to lock the file: " << szFile << endl;
    return;
    }

    本程序需要每次清空后重写
    ftruncate(fileno(fin), 0); //清空文件

    //写文件
    ......

    //解除锁
    if ( (flock(fileno(fin), LOCK_UN)) < 0 )
    {
    cout << "Fail to unlock the file: " << szFile << endl;
    return;
    }

    展开全文
  • 使用另一个程序通过上一程序返回的shmid共享内存内的数据 建立共享内存并写入数据的程序 #include #include #include #include #include #include void get_buf(char *buf) {  int i=0
    首先先使用shmget建立一块共享内存,然后向该内存中写入数据并返回该共享内存shmid
    
    使用另一个程序通过上一程序返回的shmid读该共享内存内的数据
    建立共享内存并写入数据的程序
    #include <stdio.h>
    #include <string.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdlib.h>
    #include <errno.h>
    void get_buf(char *buf)
    {
        int i=0;
        while((buf[i]=getchar())!='\n'&&i<1024)
            i++;

    }


    int main(void)
    {
        int shmid;
        shmid=shmget(IPC_PRIVATE,sizeof(char)*1024,IPC_CREAT|0666);
        if(shmid==-1)
        {
            perror("shmget");
        }
        char *buf;
        if((int)(buf=shmat(shmid,NULL,0))==-1)
        {
            perror("shmat");
            exit(1);
        }
        get_buf(buf);
        printf("%d\n",shmid);
        return 0;
    }
    读取数据的程序
    #include <stdio.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <stdlib.h>
    int main(int argc,char **argv)
    {
        int shmid;
        shmid=atoi(argv[1]);
        char *buf;
        if((int)(buf=shmat(shmid,NULL,0))==-1)
        {
            perror("shmat");
            exit(1);
        }
        printf("%s\n",buf);
        shmdt(buf);
        return 0;
    }
    命令行的第一个参数设为第一个程序输出的数字

    Linux下内存共享的一个实例(设置共享内存,一个程序写,一个程序读) - 枯龙吟 - 枯龙吟
    使用完以后可以使用
    ipcrm -m 19562507
    来删除该共享内存

    http://blog.163.com/lixiangqiu_9202/blog/static/53575037201291014947937/
    展开全文
  • 2.两个进程可以任意对文件进行读写操作,操作系统并不保证的原子性 3.进程可以通过系统调用对文件加锁,从而实现对文件内容的保护 4.任何一个进程删除该文件时,另外一个进程不会立即出现读写失败 5.两个进程可以...
  • Linux多个进程或线程同时对一个文件进行操作,如何解决冲突? 使用flock(锁定文件或解除锁定),简单可行! 先介绍一下flock函数吧 头文件 #include 定义函数 int flock(int fd,int operation); 函数...
  •  三个进程P1、P2、P3互斥使用一个包含N(N&gt;0)个单元的缓冲区。P1每次用produce()生成一个正整数并送入缓冲区某一空单元中;P2每次用getodd()从该缓冲区中取出一个奇数并用countodd()统计奇数个数;P3每次用...
  • Linux 多进程通信开发(六): 共享内存

    千次阅读 2019-04-10 19:11:37
    这会是一系列文章,讲解的内容也很简单,文章的目的是让自己的知识固话和文档化,以备自己不时的复习,同时也希望能够给予初学者一些帮助...共享内存其实很容易理解,不同的进程共享一块内存。 我们都知道,进程间通...
  • 这几个进程没有父子关系,也没有 Server/Client 关系这一片共享内存一开始不存在,第一个要访问它的进程负责新建也没有额外的 daemon 进程能管理这事情 看上去这是一个很简单的问题,实际上不简单。有两大问题: ...
  • Linux多进程 -- 创建子进程

    千次阅读 2017-07-09 13:41:57
    Linux多进程 – 创建子进程 fork函数 Linux创建单个子进程 Linux创建多个子进程 父子进程共享内容
  • 最近项目中的一个计数程序,因为会计数,所以只能有一个进程在运行,否则计数速度会加快,而刚好又是一个守护进程。Steven的《unix环境高级编程》的守护进程中就有讲,单实例进程。 这种监控有很,如果放在两年前...
  • Linux系统环境下关于多进程并发一个文件的讨论2011-09-18 14:42:19 分类: LINUX 讨论关于并发环境下,多个进程对同一文件写入的问题,我们会涉及到文件共享的知识。在开始之前,我们先讨论一些有关...
  • 进程共享时共享时复制)

    千次阅读 2019-03-25 17:15:51
    父子进程之间在刚fork后。父子相同处: 全局变量、.data、.bbs、.text、栈、堆、环境变量、用户ID、宿主目录(进程用户家目录)、进程工作目录、信号处理方式等等,即0~3G的用户空间是完全一样的。父子不同处: 1.进程...
  • Linux进程间通信——使用共享内存

    万次阅读 多人点赞 2013-08-24 10:26:39
    顾名思义,共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享...
  • linux 多进程

    千次阅读 2017-03-29 17:22:52
    Linux下的多进程编程初步Linux下的多进程编程初步 引言 多进程编程 1 Linux进程的结构 2 Linux下的进程控制 21 僵尸进程 22 fork 23 exec 函数族 3 Linux下的进程间通信 31 管道 无名管道 有名管道 32 消息队列 33...
  • Linux进程间通信之共享内存篇

    千次阅读 2018-05-26 23:45:37
    共享内存通过两个或多个进程共享同一块内存区域来实现进程间的通信,就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针。通常是由一个进程创建一块共享内存区域,然后多个进程可以对其进行访问,...
  • linux进程间通信———内存共享

    千次阅读 2017-03-16 19:08:23
    共享内存(shared memory):是linux下的多进程之间的通信方法,这种方法通常用于一个程序的多进程间通信,实际上多个程序间也可以通过共享内存来传递信息。共享内存指在多处理器的计算机系统中,可以被不同中央处理...
  •  (1) 每个进程在进程表中都有一个记录项,记录项中包含有一张打开文件描述符表,可将其视为一个矢量,每个描述符占用一项。与每个文件描述符相关联的是:  (a) 文件描述符标识(close_on_exec)。  (b)指向...
  • 共享内存允许两个或更进程访问同一块内存,就如同 malloc() 函数向不同进程返回了指向同一个物理内存区域的指针,两个进程可以对一块共享内存进行读写。 共享内存并未提供进程同步机制,使用共享内存完成进程间...
  •  他们之间的关系决定了在文件共享方面一个进程对另一个进程可能产生的影响。 0.1和文件有关的对象 (1) inode(i节点): 保存一个文件的通用信息,每个inode有一个inode number,在文件系统中,一个inode ...
  • 打开此文件的每一个进程都得到一个文件对象,但对一个给定的文件只有一个v节点表项。每个进程都有自己的文件对象的一个理由:这种安排使每个进程都有它自己对该文件的当前位移量。这种情况不会增加对应的打开文件...
  • Linux进程间通信之共享内存

    千次阅读 2016-07-28 21:04:06
    2、资源共享多个进程之间享受同样的资源 3、通知事件:一个进程需要向另一个或另一组进程发送消息,通知它们发生了某种事件。 4、进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程...
  • linux 只启动一个进程实例

    千次阅读 2014-11-01 11:55:42
    很多应用程序都只应该启动一个运行实例,特别是设计文件IO操作的程序,如果误启动了多个实例,可能会导致混乱的IO,进而导致文件乱。 常见的做法: 1.生成pid文件 这种做法最常见了,应用于大多数的Linux程序,...
  • Linux进程间通信】 - 共享内存

    千次阅读 2016-03-14 20:54:38
    今天我们来介绍Linux下最高效的种进程间通信方式 – 共享内存。什么是共享内存?顾名思义,共享内存就是两个(或多个...同块物理内存空间被映射到两个进程,两个进程都可以访问这段共享空间从而实现了进程间通信。
  • 为了解决多个线程对同一变量访问时的竞争条件问题,操作系统层面提供了锁、信号量、条件变量等几种线程同步机制。如果对变量的每次访问都使用上述机制,由于系统调用会陷入内核空间,需要频繁...
  • 一文Linux进程进程组、会话、僵尸

    千次阅读 多人点赞 2020-02-24 08:21:00
    作者简介 herongwei,北交硕士毕业,现就职于搜狗公司,后端开发工程师。从事 C++,Golang ,Linux 后端开发。追求技术,热爱编程与分享,希望能和大家多多交流学习~座右...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,590
精华内容 96,636
关键字:

linux多个读一个写进程共享

linux 订阅