动态库中的全局变量和各种锁以及信号量是否是进程独立或者共享

最新推荐文章于 2023-11-09 14:48:13 发布
最新推荐文章于 2023-11-09 14:48:13 发布
阅读量1.6k 收藏 21
点赞数 3
文章标签： 数据结构 算法 链表
原文链接：https://codeantenna.com/a/NGMUvdvHXO
版权

结论：

  • so被进程加载时，代码段共享，但是所有变量（局部、全局、静态变量）都是各进程copy一份私有使用。

一、动态库中的全局变量测试(包括static全局变量)

新建一个动态库，代码如下

#include <stdio.h>
#include "my_lib.h"
int g_val = 200;

//测试库中的全局变量是否独立或共享
static void func_1();
void func(int i)
{
    func_1();
    g_val = i;
    printf("===== g_val= %d\n", g_val);
}
static void func_1()
{
    printf("===== g_val= %d\n", g_val);
}

测试程序如下：test1.c

#include <stdio.h>
#include "my_lib.h"

int main()
{
	func(10);
	while(1)
    {
    	sleep(5);
    }
}

test2.c

#include <stdio.h>
#include "my_lib.h"

int main()
{
	func(30);
	while(1)
    {
    	sleep(5);
    }
}

执行结果如下：
test1：
===== g_val= 200
===== g_val= 10

test2:
===== g_val= 200
===== g_val= 30

结论：在共享库中的全局变量是基于进程独立的。我们知道每一个进程空间都拥有自己的进程空间。(将全局变量修改为static也是一样的运行结果)
进程空间组成如下：

在这里插入图片描述
程序段(Text):程序代码在内存中的映射，存放函数体的二进制代码。

初始化过的数据(Data):在程序运行初已经对变量进行初始化的数据。

未初始化过的数据(BSS):在程序运行初未对变量进行初始化的数据。

栈 (Stack):存储局部、临时变量，函数调用时，存储函数的返回指针，用于控制函数的调用和返回。在程序块开始时自动分配内存,结束时自动释放内存，其操作方式类似于数据结构中的栈。

堆 (Heap):存储动态内存分配,需要程序员手工分配,手工释放.注意它与数据结构中的堆是两回事，分配方式类似于链表。

在应用程序编译的时候，不同的应用程序引用同一个库，那么动态库的代码是共享的。只有一份，但是数据却是每一个进程空间一份拷贝。(这里的数据包括库中的全局变量和静态变量)。所以一个应用程序修改库中的全局变量也不会影响到另一个库的引用。因为数据是独立的，代码是共享的。

二、动态库中使用进程间同步互斥机制

当我们在动态库中使用一些进程间同步互斥的代码的时候，调用这些库的app之间是否会相互受到影响呢？(线程间同步互斥的机制肯定没有影响)。这里采用文件锁来测试

动态库代码如下：

#include <unistd.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include "my_lib.h"
static int g_val = 200;

//测试库中的进程同步互斥机制是否有影响
void func(int i)
{
    FILE *f = fopen("test_1.c", "r");
	if(0 == flock(fileno(f), LOCK_EX))
    {
        printf("==================\n");
        sleep(100);
        fclose(f);
        flock(fileno(f), LOCK_UN);
    }
}

测试代码test1.c

#include <stdio.h>
#include "my_lib.h"

int main()
{
	func(10);
	while(1)
	{
		sleep(5);
	}
}

测试代码test2.c

#include <stdio.h>
#include "my_lib.h"

int main()
{
	func(10);
	while(1)
	{
		sleep(5);
	}
}

在这里插入图片描述
在这里插入图片描述
结论：用于动态库中使用了进程间同步互斥代码，所以调用该库的app相互之间是有影响的
总结：全局变量 静态变量在库中 可以随便用，进程间通信的一些同步互斥手段慎用

最近对多线程调用时，动态链接库的全局变量有了以下几点认识。

1、动态链接库被同一进程的多个线程加载时，全局变量的值是进程有效。

例如：动态链接库C.dll有一个全局变量 int
g_iCount=0（初始值）。某一函数Method_D被调用一次，则g_iCount++。

当某一进程加载C.dll后，线程A、B先后调用Method_D后，线程A获得的C.g_iCount=1，但线程B获得的C.g_iCount则是2。

这是因为线程B调用Method_D前，g_iCount已经被线程A更改。

2、虽然说动态链接库的全局变量是进程级的，但并不是说 同一进程里，不同模块定义同名全局变量就可以互相传递数值。

这跟我们的函数一样，即使在同一进程空间里，定义成相同名字跟结构，只要没有做导出，外部模块还是不能调用的。

所以，如果想在同一进程的不同线程间共享某一数据，也可以在全局变量定义时，使用_declspec(dllexport) 将其导出，

在调用处使用GetProcAddress()取得其在进程空间的地址来使用。

三、互斥锁共享

也就是说，想要在so内实现一个不可重入的函数还是比较困难的，因为所有变量都是独立的，但是考虑如下场景：驱动层给了一个视频码流录制的接口，并且没有在驱动层做互斥，但实际上这个接口同一时间只可能被一个进程调用，那么很明显，串接到so中的接口必须实现该接口的原子调用。

解决思路：

  • 由so创建一块共享内存，放置一份进程共享的互斥锁
  • 第一步的动作需要寻找一个合适点自动完成，比如so加载时
  • 各进程在调用so接口时，接口内部使用该共享锁完成互斥调用

1、创建互斥锁

so中的互斥锁属于私有数据，加载该so的进程都会拷贝一份，那么就无法在进程间共享使用该锁。所以必须将锁放到进程间的共享内存中，确保锁只有一把。首先定义一个锁结构体

// 定义进程锁结构体
typedef struct Mutex_Info {
    // 锁以及状态
    pthread_mutex_t lock;
    pthread_mutexattr_t lock_attr;
    // 在共享内存中的标识符
    int FLAG;
} mutex_info_t;

要想把锁放到共享内存，那么先创建一块内存

/**
 *  返回一片共享内存标识符，用于后续获取该共享内存，以及销毁该共享内存
 *  INDEX_OF_KEY —— 自定义的该共享内存序号
 *  LENGTH —— 共享内存大小
 */
const int create_sharemem(const int INDEX_OF_KEY, const unsigned int LENGTH) {
    // 生成key
    const char* FILE_PATH = "./";
    key_t key = ftok(FILE_PATH, INDEX_OF_KEY);

    // 创建共享内存空间 
    //多个进程调用该函数，只要确保KEY相同，那么只会创建同一块内存
    const int FLAG = shmget(key, LENGTH, IPC_CREAT | 0666);
    return FLAG;
}

其中的init函数是锁的初始化，注意需要设置其进程间共享属性

const int init_mutex(void* pthis) {
    mutex_info_t* mp = (mutex_info_t*)pthis;
    // 初始化锁状态，设置状态状态为——进程共享
    pthread_mutexattr_init(&(mp->lock_attr));
    pthread_mutexattr_setpshared(&(mp->lock_attr), PTHREAD_PROCESS_SHARED);
    // 用锁状态来初始化锁
    pthread_mutex_init(&(mp->lock), &(mp->lock_attr));
    return 0;
}

有了以上两个函数，其实就可以写一个so被加载时自动执行的初始化函数，这样可以保证so的使用者不必关心内存、锁的创建、销毁和使用。所以先插讲下so加载时自动执行函数的方法

2、so加载时自动执行函数

GNU C 的一大特色就是__attribute__ 机制。attribute 是一个编译指令，可以设置函数属性（Function Attribute ）、变量属性（Variable Attribute ）和类型属性（Type Attribute ）。
attribute 书写特征是：attribute 前后都有两个下划线，并切后面会紧跟一对原括弧，括弧里面是相应的__attribute__ 参数。
若将某一函数的声明中添加 __ attribute__((constructor)) 属性，那么它具有两种运行时机

若函数所在源文件被编译为可执行文件，那么该函数可以在main函数执行前被调用

#include <stdio.h>
#include <stdlib.h>
static int * g_count = NULL;
__attribute__((constructor)) void load_file()
{
    printf("Constructor is called.\n");
}
__attribute__((destructor)) void unload_file()
{
    printf("destructor is called.\n");
}

int main()
{
   printf （"this is main function\n"）；
    return 0;
}

若函数所在源文件被编译为共享库，那么该函数可以在共享库被其它进程显式dlopen或者隐式由操作系统加载时都会优先执行

//process source file
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>

int main(int argc, char **argv)
{
	void (*print)();
	int (*add)(int, int);
	void *handle;
	
	if (argc < 2)
		return -1;
	
	handle = dlopen(argv[1], RTLD_LAZY);
	if (!handle) {
		printf("dlopen failed: %s\n", dlerror());
		return -1;
	}
	
	print = dlsym(handle, "print");
	if (!print) {
		printf("dlsym failed: %s\n", dlerror());
		return -1;
	}
	print();
	
	add = dlsym(handle, "add");
	if (!add) {
		printf("dlsym failed: %s\n", dlerror());
		return -1;
	}
	add(1, 2);
	
	dlclose(handle);
	
	return 0;
}


//libss.so source file

#include <stdio.h>
#include <string.h>

void print() 
{
	printf("I am print\n");
}

int add(int a, int b)
{
	printf("Sum %d and %d is %d\n", a, b, a + b);
	return 0;
}
//static void king() __attribute__((constructor(101))); the following is also right
static __attribute__((constructor(101))) void king()
{
	printf("I am king\n");
}

gcc -Wall -shared -fPIC -o libss.so libss.c -ldl

gcc -Wall -o udlopen udlopen.c

./udlopen libss.so

I am king
I am print
Sum 1 and 2 is 3

__ attribute__((constructor))的这一特性可以被用在许多场合。比如某个so的功能实现需要预先映射一块共享内存，如果要求所有使用该so的进程在加载时手动去做这一步骤是非常不合理的，此时可以将内存映射实现放在__ attribute__((constructor))属性声明的函数中，这样每次so被加载就会自动完成共享内存的创建映射，对so的使用者完全透明，确实够巧妙！

3、so加载时自动创建共享内存与互斥锁

//全局变量
mutex_info_t tPtr = NULL;
__ attribute__((constructor)) static void pre_init(void)
{
      int flag = create_sharemem(127, sizeof(mutex_info_t ));
      //NULL参数代表由操作系统选择共享内存中的合适位置返回给内存申请者，测试发现由于共享内存一共就只有mutex_info_t 大小，
      //所以每次返回的地址相同 这也能保证so被多个进程加载使用的是同一把锁
      tPtr = (mutex_info_t *)shmat(FLAG, NULL, SHM_R | SHM_W);
      //内存内结构体的FLAG如果不是共享内存的索引，那么表示是第一次申请内存，需要对锁初始化
      //避免多次加载so时多次init锁
      if(tPtr->FLAG != flag)
      {
		 	tPtr->FLAG == flag;
		 	init_mutex(tPtr);
		 	printf("first make mem, init lock");
	   }
	   else
	   {
			printf("mem, lock has been init");
	    }
}

__ attribute__((destructor)) static void late_destory(void)
{
	  struct shmid_ds shminfo;
      //共享内存有引用计数，所以多次写在so调用释放共享内存时，只有最后计数为0时才会真正释放
	  shmctl(tPtr->FLAG, IPC_RMID,NULL);
      shmctl(tPtr->FLAG, IPC_STAT,&shminfo);
      //虽然tPtr不能被进程共享，但是每个进程的SO呗加载时都会重新更新tPtr的值，所以可放心使用
      //当内存引用计数变为0时（实际测试是1），代表so不被使用，可销毁锁
      if(shminfo.shm_nattch == 1)
      {
            pthread_mutex_destory(&(tPtr->lock));
            pthread_mutexattr_destory(&(tPtr->lock_attr));
      }
}

有了保护机制，可以再写一个接口，接口假设不可重入：

void Asyncprint()
{
	pthread_mutex_lock(&(mp->lock));
	printf("now you can call me");
	sleep(10);
	printf("all me finish!");
	pthread_mutex_unlock(&(mp->lock));
}

以上函数模拟的场景是：Asyncprint执行一次需要10s，中间不允许重入，so编译方法：

gcc lock.c -fPIC -shared -o liblock.so

可以同时跑两个相同进程调用该so的接口，看看接口是否互斥调用

//main.c
//gcc main.c -L. -llock -lpthread -o 1.exe
//gcc main.c -L. -llock -lpthread -o 2.exe
//可同时使用ipcs -m c查看共享内存信息
#include <stdio.h>
#include "lock.h"
int main()
{
   Asyncprint();
}

同时运行1.exe 2.exe看打印：
在这里插入图片描述

完整源码：

//main.c 
//gcc lock.c -fPIC -shared -o liblock.so    编译动态库
//gcc main.c -L.  -llock  -lpthread -o 1.out 编译可执行程序1
//gcc main.c -L.  -llock  -lpthread -o 2.out 编译可执行程序2
//ipcs -m shell中查看当前shm情况
#include <stdio.h>
#include <sys/shm.h>
#include "lock.h"
int main() {

    //方式1 可执行程序自己调用函数分配共享内存，创建互斥锁
	//此时需删除lock.c中的constructor与desstructor函数
    /*mutex_info_t * mp = create_mutex_package(111);
    shmctl(557060, IPC_RMID, NULL)
    asyncprint();
    destory_mutex_package(mp); 
	*/
	//方式2 内存与互斥锁均由so加载时，其自己的constructor与desstructor函数负责创建与销毁
	asyncprint();

	return 0;

}

//lock.h
#ifndef __LOCK_H_
#define __LOCK_H_

#include <pthread.h>


typedef struct MUTEX_PACKAGE {

    pthread_mutex_t lock;
    pthread_mutexattr_t lock_attr;

    int FLAG;
} mutex_info_t ;

extern const void asyncprint();
#endif

lock.c

//gcc lock.c -fPIC -shared -o liblock.so

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

#include "lock.h"

mutex_info_t * mp = NULL;
int FLAG =0;
/**
 *  返回一片共享内存标识符，用于后续获取该共享内存，以及销毁该共享内存
 *  INDEX_OF_KEY —— 自定义的该共享内存序号
 *  LENGTH —— 共享内存大小
 */
const int create_sharemem(const int INDEX_OF_KEY, const unsigned int LENGTH) {
    // 生成key
    const char* FILE_PATH = "./";
    key_t key = ftok(FILE_PATH, INDEX_OF_KEY);

    // 创建共享内存空间
    const int FLAG = shmget(key, LENGTH, IPC_CREAT | 0666);

    return FLAG;
}



// 初始化进程锁结构体
const int init_mutex(void* pthis) {
    mutex_info_t * mp = (mutex_info_t *)pthis;
    // 初始化锁状态，设置状态状态为——进程共享
    pthread_mutexattr_init(&(mp->lock_attr));
    pthread_mutexattr_setpshared(&(mp->lock_attr), PTHREAD_PROCESS_SHARED);
    // 用锁状态来初始化锁
    pthread_mutex_init(&(mp->lock), &(mp->lock_attr));

    return 0;
}


__ attribute__((constructor)) static void pre_init(void)
{
      int flag = create_sharemem(127, sizeof(mutex_info_t ));
      //NULL参数代表由操作系统选择共享内存中的合适位置返回给内存申请者，测试发现由于共享内存一共就只有mutex_info_t 大小，
      //所以每次返回的地址相同 这也能保证so被多个进程加载使用的是同一把锁
      tPtr = (mutex_info_t *)shmat(FLAG, NULL, SHM_R | SHM_W);
      //内存内结构体的FLAG如果不是共享内存的索引，那么表示是第一次申请内存，需要对锁初始化
      //避免多次加载so时多次init锁
      if(tPtr->FLAG != flag)
      {
		 	tPtr->FLAG == flag;
		 	init_mutex(tPtr);
		 	printf("first make mem, init lock");
	   }
	   else
	   {
			printf("mem, lock has been init");
	    }
}

__ attribute__((destructor)) static void late_destory(void)
{
	  struct shmid_ds shminfo;
      //共享内存有引用计数，所以多次写在so调用释放共享内存时，只有最后计数为0时才会真正释放
	  shmctl(tPtr->FLAG, IPC_RMID,NULL);
      shmctl(tPtr->FLAG, IPC_STAT,&shminfo);
      //虽然tPtr不能被进程共享，但是每个进程的SO呗加载时都会重新更新tPtr的值，所以可放心使用
      //当内存引用计数变为0时（实际测试是1），代表so不被使用，可销毁锁
      if(shminfo.shm_nattch == 1)
      {
            pthread_mutex_destory(&(tPtr->lock));
            pthread_mutexattr_destory(&(tPtr->lock_attr));
      }
}
绛洞花主敏明
关注
  • 3
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态链接
u012588160的博客
09-01 971
动态链接 命令： gcc： -static：产生静态库 -shared：产生共享库 一.静态链接和动态链接的优缺点： 静态链接： 空间的浪费：静态链接，程序最后都会链接成一个可执行文件，那么功能相同的模块（可以用来共享），在每一个需要使用的程序中都有一个份，这样就会对计算机的内存和磁盘空间造成浪费。 更新、部署、发布困难：当需要更新功能相同的模块（可以用来共享）时，所有的程序需要重新连接。 动态链接： 不对那些组成程序的目标文件进行链接，等到程序要运行时才进行链接。 节省空间，提供缓存命中率：在内
动态库中的全局变量与静态变量
木牛的博客
07-06 2929
之前在linux下做过一个测试：写一个so，该so中有一个全局变量。so中的代码在运行时会修改该全局变量的值。然后，有多个程序都需要该so，而且这些应用程序都启动了。此时，很显然so只被加载了一份，那么，当这么多程序在运行调用该so时，该so中的全局变量的值会被覆盖来覆盖去么？答案是不会。这是测试的答案。现在知道原理了，尽管这是windows via C/C++中解释的windows的做法，但是我想linux也是这么类似处理的。windows 使用memory map来加载exe和dll。当一个exe/dl
linux动态链接库全局变量共享问题&DLL共享数据段
热门推荐
zxh821112的专栏
05-24 3万+
Linux写时拷贝技术(copy-on-write) 进程间是相互独立的，其实完全可以看成A、B两个进程各自有一份单独的liba.so和libb.so，相应的动态库的代码段和数据段都是各个进程各自有一份的。 然后在这个基础上，由于代码段是不会被修改的，所以操作系统可以采用copy on write的优化技术，让两个进程共享同一份物理内存。这是属于在不改变系统行为的基础上，为了节省内存，
C语言-动态库里的全局变量/静态变量
dreamtale90的博客
11-27 4071
动态库里的全局变量/静态变量 一般情况 动态库在被系统加载后，代码段只有一份，所有使用者共享。对于代码段要分两种情况： 如果是多进程的话，数据段在每个进程中拥有一个独立的副本，所以数据是安全的。 如果是多线程的话，数据段在同一个进程中是同一个地址空间，所以数据是不安全的。 共享数据段 共享数据段可以解决多个进程希望通过一个动态库里的某个全局变量来实现进程间通信的问题。 ...
全局变量初始化时机测试（动态库，静态库，执行程序中）
最新发布
CHNIM的博客
11-09 463
如果动态库是动态加载的，也就是在程序运行时才根据需要加载动态库，那么动态库中的全局变量会在加载动态库时初始化，和动态库中的静态变量一样。如果动态库是静态加载的，也就是在编译链接时就确定了动态库的位置和符号，那么动态库中的全局变量会在程序启动时就初始化，和静态库中的全局变量一样。动态库中的全局变量是指在动态库中定义的非静态变量，它们可以被动态库中的其他函数或者加载动态库的程序访问。动态库中的全局变量什么时候初始化，取决于动态库的加载方式和操作系统的实现。linux 和 windows。
Linux下的多进程编程初步.doc
06-23
代码段存储程序代码，堆栈段存放子程序信息和局部变量，数据段则保存全局变量和动态分配的内存。 2. **Linux中的进程结构** - **代码段**：同一程序的多个进程可以共享同一代码段，节省内存。 - **堆栈段**：每个...
计算机四级网络工程师题库完整版(完整答案).doc
09-29
6. 进程控制块（PCB）与进程：PCB包含了进程的状态、优先级、进程ID等信息，而不包括需要访问的数据文件名、全局变量和堆栈，这些通常存在于进程的内存空间中。 7. 进程关系：并发执行的进程通常不存在主从关系或...
嵌入式应用开发期末练习题.docx
02-22
数据区又分为静态数据区（存放全局变量和静态变量）和动态数据区，动态数据区包括堆（动态分配内存）和栈（存放函数调用时的局部变量和函数参数）。 6. **Linux管道通信**：Linux的管道通信分为匿名管道、有名管道...
程序员嵌入式软件岗位笔试面试最常考的基本概念题
11-29
本文将重点解析标题和描述中提及的一些关键知识点，包括操作系统进程线程的区别、进程同步机制及其优缺点、进程间通信与线程通信的方式，以及实时系统、线程同步对象和线程使用的时机。 1. **进程线程的区别** - *...
POSIX 线程详解
08-29
线程的一个主要优势在于它们之间的内存共享，这意味着各个线程可以访问和修改全局变量，简化了进程间的通信问题。 与传统的进程模型相比，使用线程创建、销毁的开销较小，因为它们不需要复制整个进程的内存空间。...
C++导出和使用动态库DLL（涉及全局变量）
GreatXiang888的博客
12-07 2671
C++导出和使用动态库DLL（涉及全局变量）
动态库中的全局变量_开发过程中的全局动态动态交付
weixin_26729841的博客
08-18 584
动态库中的全局变量This is the first article in a three part article series on how you can leverage GloballyDynamic to accomplish tasks such as: 这是由三部分组成的系列文章中的第一篇，该系列文章介绍如何利用GloballyDynamic完成以下任务： Enabling dy...
论动态库中的全局变量和各种锁以及信号量是否是进程独立或者共享
小小程序员的博客
05-27 1425
动态库中的全局变量测试 新建一个动态库，代码如下 #include <stdio.h> #include "my_lib.h" int g_val = 200; //测试库中的全局变量是否独立或共享 static void func_1(); void func(int i) { func_1(); g_val = i; printf("===== g_val= %d\n", g_val); } static void func_1() { printf("==
静态库与动态库全局变量及函数深入了解
u012385733的专栏
07-04 6241
一．静态库全局变量与当前应用全局变量重名编译出错，提示多次定义，因为静态可以看作本是应用的一部分，所以会报重定义． 二．动态库全局变量与当前应用全局就量重名编译不会出错，当前应用全局变量覆盖动态库全局变量． 三．静态库全局变量与动态库全局变量重名编译不会出错，先链接谁，谁优先．如果多个静态库全局变量重名，编译出错． 四，动态库变量被多个进程使用会出现重入问题？不会． 当so被load的时候，会把s...
在主程序及动态链接库里的全局变
木牛的博客
06-05 300
曾经在一次写程序的时候，全局使用一个日志对象，所有的日志信息都由此日志对象写入文件。但是发现在动态链接库里，无法存取到该全局对象，后经查找资料。发现，动态链接库是否能存取主程序的全局变量，主程序是否能存取动态链接库里定义的全局变量都是可以通过链接指令改变此行为。 主程序存取动态链接库里的全局变量 例如动态库里定义全局变量int i, 在主程序里申明extern int i。 则，主程序存取的就是动态库里定义的i。在所有的UNIX平台上这是默认的行为（注意：实际定义i的 模块的点o文件，必须同时链接到动态库和
【c++】——动态库中全局变量
怡宝2号
10-09 1962
转载自：https://www.cnblogs.com/super119/archive/2011/04/10/2011305.html 之前在linux下做过一个测试： 写一个so，该so中有一个全局变量。so中的代码在运行时会修改该全局变量的值。然后，有多个程序都需要该so，而且这些应用程序都启动了。此时，很显然so只被加载了一份，那么，当这么多程序在运行调用该so时，该so中的全局变量的值会被覆盖来覆盖去么？ 答案是不会。这是测试的答案。 现在知道原理了，尽管这是windows via C/C++中解
静态库和动态库里的全局变量（或类的静态成员变量）共享和独立的问题
峻峰飞阳的博客 blog.csdn.net/while0
11-01 1万+
本文将要讨论的内容实际上包含2个问题： 1. 工程中包含静态库A，动态库B，可执行程序C。C依赖于A和B，而B依赖于A。在A中定义有全局变量X（或类的静态成员变量)，则在动态库B中访问的X，与可执行程序C中访问的X是同一个变量还是两个不同的变量？ 答案：是两个不同的变量。 测试代码如下： //A中定义变量g_nValue(A.cpp): int g_nValue = 0;
在某lib库中定义的全局变量能够在多进程间共享
05-31
这个需要具体情况具体分析。通常情况下，在某个库中定义的全局变量只能在当前进程中共享，而不能在多个进程之间共享。这是因为不同进程之间的内存空间是相互独立的，每个进程都有自己独立的虚拟地址空间，它们之间无法直接访问对方的内存。 但是，如果在进程间通信的机制中使用了共享内存技术，那么就可以实现在多个进程之间共享某个全局变量。共享内存是一种特殊的内存映射，可以将同一块物理内存映射到多个进程的虚拟地址空间中，从而实现进程间的共享。在这种情况下，多个进程可以通过访问共享内存中的全局变量来实现数据共享。 需要注意的是，如果要在多个进程之间共享全局变量，需要使用特殊的技术来确保数据的安全性和一致性，避免数据竞争和死锁等问题。常见的方法包括使用互斥锁、信号量等进程同步机制来保护共享数据的访问，以及使用进程间通信的方式来协调数据的更新和读取。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值