我发现在share library中的全局变量,静态全局变量都是私有的,也就是说无法在多个加载这个库的进程中共享.我用google搜了一下,发现也有人遇到我这个问题,请问有人知道如何解决吗?
也就是说,如何实现进程A修改了一个共享库中定义的变量x,使另外一个也加载了这个共享库的进程中的x也发生变化.问题的英文描述如下:
Hi,

I wrote a shared library and I know the code of the
shared library  will be shared between different
applications. However,  the global data of the library
cannot be shared.

For example,  the code of the shared library looks
like 

// myshare.c
#include 

int global = 5;

void printGlobal()
{
        printf("Global=%dn",global);
}

void setGlobal(int g)
{
        global = g;
}

I used the following command to create the library
$gcc -fPIC -shared -o libmyshare.so myshare.c

The user application 1 links with it
//u1.c
#include 

extern void setGlobal(int);

int main()
{
        setGlobal(50);
        return 0;
}

I used the following command to create u1
$gcc -o u1 u1.c -L. -lmyshare

The user application 2 links with it too
//u2.c
#include 

extern void printGlobal(int);

int main()
{
        printGlobal();
        return 0;
}

I used the following command to create u2
$gcc -o u2 u2.c -L. -lmyshare

Then, I run u2 and u1
$u2
Global=5
$u1
$u2
Global=5

It seems that from u1, setGlobal(50) does not affect
the
print out of u2, which means, when u1 and u2 link with
the shared library libmyshare.so, there are two 
copies
of the global data in libmyshare.so.  So the code is
shared,
but not the global data.

My question is:  is there any way to share the global
data
within a shared library, i.e, both code and data can
be shared?

(I know I can use shared memory, but I wonder if we
can
do it using special compiler settings.)

按照我的理解两个进程使用一个共享库的时候只有.text段是共享的，也就是说只共享只读部分，比如 可执行 代码和符号表，这样同时使用同一个共享库的进程才可以互不干扰，保证正确性。而全局或静态变量应该是在.bss或者.data段的，所以连接到不同的程序中时会有不同的copy。

这是只有一个全局变量的共享库：
/*
 * file:     a.c
 *
 * target:   liba.so
 * command:  cc -fPIC -shared -o liba.so a.c
 */
int extern_var_in_so = 0;

这是调用上面共享库的可执行文件：
/*
 * file:     main.c
 *
 * target:   main.o
 * command:  cc -c main.c -o main.o
 *
 * target:   main
 * command:  cc main.o -L. -la -o main
 */
extern int extern_var_in_so;
int local_var_in_main = 0;

int main()
{
  return extern_var_in_so + local_var_in_main;
}

在使用cc -c main.c -o main.o编译完main.c时，用nm main.o查看main.o:
         U extern_var_in_so
00000000 B local_var_in_main
00000000 T main
可以看到，本地变量local_var_in_main的位置是在bss段;
而外部变量extern_var_in_so还是没有定位(undefined)，需要在链接之后定位；

使用cc main.o -L. -la -o main命令把main.o, liba.so链接为可执行文件main,用nm main查看：
...
08049618 B extern_var_in_so
...
08049620 B local_var_in_main
...
注意到这里extern_var_in_so和local_var_in_main都在bss段里，没有什么区别。

以上是我个人理解，不一定准确，也许还是错误的，不过还是希望对你能有帮助。