发现和了解你未来的雇主页面已拦截
无锡网警提示您：
该网站已被大量用户举报，存在代办假信用卡的嫌疑，可能会骗取您的手续费或窃取您的个人信息，建议您谨慎访问。关于java里面的全局变量的内存分配 - 高级语言虚拟机 - ITeye群组
今天突然想到一些问题，关于java内存分配的问题，基本类型在栈上分配。new出来的对象引用分配在栈上，对象分配在堆上，一直以来都是记住了，从来没仔细思考过，在栈上到底怎么分配，在堆上到底具体怎么分配的。举个例子：
class Test{
private int i=9;
private int j=9;
public static void main(String args[]){
Test t=new Test();
System.out.println(t.i==t.j);//true
System.out.println(t.i==w);//true
}
很明显t的引用在栈上，也就是指针，对象分配在堆上，在程序中我是故意让他们的值都相等，我就是想看他们是怎么分配的。w毫无疑问在栈上。但是对象的属性i,j在哪里分配，通过运行的结果貌似也在栈上，因为栈上有优化。i,j,w都指向了存贮9这个值的地址。我今天看到一句话是这么说的，
　& 1）方法本身是指令的操作码部分，保存在Stack中；
　　2）方法内部变量作为指令的操作数部分，跟在指令的操作码之后，保存在Stack中（实际上是简单类型保存在Stack中，对象类型在Stack中保存地址，在Heap 中保存值）；上述的指令操作码和指令操作数构成了完整的Java 指令。
　　3）对象实例包括其属性值作为数据，保存在数据区Heap 中。
　　非静态的对象属性作为对象实例的一部分保存在Heap 中，而对象实例必须通过Stack中保存的地址指针才能访问到。因此能否访问到对象实例以及它的非静态属性值完全取决于能否获得对象实例在Stack中的地址指针。
也就是说数据放在堆上，在此我有疑问，到底怎么分配？
最近项目周期很紧所以暂时回复不了什么，下下周应该能稍微解脱一两天吧，到时候画些图来说明这个。大家有兴趣讨论的请先踊跃发表见解哦～
先简单写几句：
1、一定要留意，JVM规范所规定的“概念中的JVM”与实际的JVM实现是可以有差异的。所以请区分清楚“堆”、“栈”在概念中与实际实现中的不同。我猜多数Java程序员更关心（或者说更有用）的是概念中的JVM的状况，但请千万不要想当然的认为实际上也必须要那样实现。
不过，作为一种现象，我们可以观察到用解释器实现的JVM会比用JIT编译器/混合模式方式实现的JVM要更接近于概念中的JVM。
2、请留意，“地址”、“指针”、“引用”等是不同抽象层次的概念，并不等价。
·引用可以用指针来实现，也可以用handle（一般翻译为“句柄”？总之很怪）来实现；
·指针里可以直接包含地址，也可以包含地址的某种映射关系（例如HotSpot中的compressedOop）；
·地址可以是不同意义上的地址，在常见的Linux、Windows等现代操作系统上一般有虚拟内存系统，因而所谓“地址”在这里一般指虚拟内存的地址而不是所谓的“物理内存地址”。“物理内存”是一个经常被滥用、误用的词，也要注意判断。
后面几点没有特别说明的话都是针对概念上的JVM而言的。
3、Java是一种静态与动态类型相结合的强类型语言，表现在：
·Java的变量有类型，值也有类型，而且变量与值的类型并不需要精确一致，只要满足赋值匹配的约束即可；
·Java变量的类型可以是原始类型或引用类型的，其中引用类型又包括类类型、接口类型与数组类型；
·Java值的类型也可以是原始类型或引用类型的，其中引用类型的值包括指向类的实例的引用或者指向数组实例的引用；
·Java的类型系统中，所有与原始类型相关的操作都可以在Java源码编译时完成类型检查，并且在运行时不需要做额外的检查来保证类型安全；而引用类型的相关操作中有部分带有运行时检查的必要，例如强制向下类型转换、对元素为引用类型的数组的元素赋值，等等；
·Java中虚方法的实际调用目标在Java源码编译时无法确定，概念上需要在运行时根据值的实际类型来分派，与上一条提到的动态类型检查一起表现了Java的动态性。
4、原始类型的变量如果是成员变量，那么它的存储空间就正好是其所在对象中的一部分，是在Java堆上的。引用类型的变量……嗯回头有空画图了再详细说。
5、原始类型变量之间的==与!=所做的是相等性比较——值是否相等，而引用类型变量之间的==与!=做的是同一性比较——是否指向同一对象。其实如果可以理解“引用”的本质就是多了一个间接层的话，这个非常好理解，因为引用间的比较实质上也是值比较。这跟“Java中方法调用的参数传递全部是按值传递”底下的道理是一样的。
6、如果把方法的代码看作它的“静态”部分，而把一次方法调用需要记录的临时数据看做它的“动态”部分，那么每个方法的代码是只有一份的，存储于JVM的方法区中；每次某方法被调用，则在该调用所在的线程的的Java栈上新分配一个栈帧，用于存放临时数据，在方法返回时栈帧自动撤销；
7、Java程序中没有全局变量的概念。相似的概念只有“静态变量”。概念上它也是存储在方法区里的。
于是……等我回头画图吧，呵呵 ^_^
这么说吧，应该区分这些东西：
1.JVM的内存组成
JVM是一个进程，它的内存有进程Heap构成。这个进程Heap，又可以分成Java Object Heap和非Java Object Heap。
Java Object Heap，我们知道是放置Java的对象，它是分代的。
而非Java Object Heap，它主要放置：
& a)Permanent Generation，就是永久代
& 在JVM启动时候，可能设置这个东东 -XX:PermSize 和-XX:MaxPermSize
& b)Code Generation
& 用于将字节码转化成Native Code
& c)Socket Buffers
& d)Thread Stacks
& e)Direct Memory Space
& f)JNI Code
& g)Garbage Collection
& h)JNI Allocated Memory
这些解释，我可能会写一篇文章说明吧。
其中Thread Stacks，这就是线程栈，JVM通过main方法启动main thread来做的（在一定程度上Process和Thread区别），那么每个线程都有一定的栈空间大小，可以通过启动参数–Xss来设置大小。自然它是有限的，因此当无限递归的时候会出现StackOverflow的错误。
那么，方法的调用在Stack就有一个frame，等方法return之后，那么这个栈的所有的frame逐个出栈，因此，每一帧的进入叫做压栈，return之后就出栈。
当每一个线程调用自己的栈中的变量，所以方法内部的局部变量是线程安全的，这种技术被经常提起，叫做重进入（reentrance)。栈中还有方法中的参数变量。
这里注意一点，无论是方法内部的对象，参数对象，还是成员对象，都是保存在Heap里面的，包括是“引用”类型，还是原生类型。上面说的变量是元信息，可以看作一个label-标识。这些元信息不保存在Java Object Heap 区域。保存在什么地方呢？请参考2。
2、元信息
从源代码的角度来说，元信息是指类的变量和方法定义等信息。从编程的角度来说，就是程序通过反射得到的那些个成员。在元信息中定义的变量名称均放到了方法区中，这个区域是非Heap区域。
那么这些元信息保存在什么地方呢？方法区！这么说依然很是模糊。
这么说吧，在理解ClassLoader的原理之后，那么就知道一般不特殊调用defineClass来重新定义类的结构的话，那么类的结构是“不变”的。那么类自带了自己的元信息，这些信息一般不会被GC，这样就能回答为什么不在Java Object Heap区，方法区的实现区域在JVM是不统一的。
3、“引用”、地址和指针
“引用”，在Java中没有真正的C++概念中的引用，只不过套了这么个词。地址，一般而言，是指物理地址。指针是一个指向物理地址的变量。那么前面提到，每一个变量都是一个标识，Java的“引用”就是一种“传值”引用，也就说只有操作的权利，没有修改物理地址和空间的途径。这就是为什么obj = null,并没有把实际对象给null掉，而是当前变量不在指向上次的对象区域。从而，可能帮助GC，不一定就不可达了。比如：
public void calcuate(Object obj){
}
外层调用calcuate("AAAA"), "AAAA"不会被null,也不会GC掉。
4、比较
& == 和equals都是比较操作，当然还有compare方法。 == 在Java中，类似于C++操作符重载， == 在“引用”类型和原生类型。引用中是物理地址的比较，这里的物理地址可能是JVM的相对地址，也可能是实际机器地址。而原生型，是数值比较。内存空间的10比较。
不知道，楼主能不能理解我说的。如果我有错误的话，希望各位指正。
首先多谢高手们的指教啊，菜鸟我还真不太懂。看了回复后，我感觉我的疑问越来越多。在这里我说一下：
1，对于“Java中方法调用的参数传递全部是按值传递”这句话我有疑问啊，我一直都是觉的java里面的参数传递是：
"java传递是引用的拷贝，既不是引用本身，更不是对象"。对于这句话我的理解是，方法里面的原始类型在栈上分配。具体分配是一个引用，(呵呵，也叫句柄) 一个值。句柄指向那个值。在栈上分配的原始类型。栈上会自动优化。就是当它发现两个相等的值的时候。两个变量的引用会同时指向第一个值。而不会去在栈上开辟另一块空间，所以当我用==判断时，从表现上看你即可以觉的他们是值相等，也可以认为他们是引用相同。jvm具体实际情况我就不太懂。所以同理，传递参数时也相同。我觉的网上的意见实在是太多了，今天说这个，明天说那个。都把我弄晕了。
2，对于对象的成员变量，(我叫全局变量，这里名称错误，我觉的应该叫动态属性），静态属性对应于类变量。现在的理解是，动态属性应该分配在堆上。静态属性分配在栈上。在JVM中，静态属性保存在Stack指令内存区，动态属性保存在Heap数据内存区。"Java程序中没有全局变量的概念。相似的概念只有“静态变量”。概念上它也是存储在方法区里的。" 这句话，好像与我上句话有点矛盾啊，呵呵，总之，资料看的比较多，这里说是这样，哪里又说是那样，实在是头大啊！下面是网上的原话：
静态属性和动态属性：
前面提到对象实例以及动态属性都是保存在Heap 中的，而Heap 必须通过Stack中的地址指针才能够被指令（类的方法）访问到。
因此可以推断出：静态属性是保存在Stack中的，而不同于动态属性保存在Heap 中。正因为都是在Stack中，而Stack中指令和数据都是定长的，因此很容易算出偏移量，也因此不管什么指令（类的方法），都可以访问到类的静态属性。也正因为静态属性被保存在Stack中，所以具有了全局属性。在JVM中，静态属性保存在Stack指令内存区，动态属性保存在Heap数据内存区。这是网上的原话，我看那个深入jvm，如下图：
类数据(静态属性)放在方法区。跟你说的一样。这实在是头痛。我对于动态属性(非静态成员变量)在堆上分配，无疑问,但是静态属性(静态成员变量)到底在方法区，还是在栈上的Stack指令内存区，我不太确定?我觉的应该是在方法区。
3.java虚拟机规范并没有具体给出java对象在堆中是如何表示。所以对于具体分配我们无法知道，不过给出了两种可能的设计情况。
一个可能的堆的设计是将堆分为两个部分：引用池和对象池。一个对象的引用就是指向引用池的本地指针。每一个引用池中的条目都包含两个部分：指向对象池中对 象数据的指针和
方法区中对象类数据的指针。这种设计能够方便Java虚拟机堆碎片的整理。当虚拟机在对象池中移动一个对象的时候，只需要修改对应引用池中 的指针地址。但是每次访问对象的数据都需要处理两次指针。 如下图：
另一种堆的设计是：一个对象的引用就是一个指向一堆数据和指向相应对象的偏移指针。这种设计方便了对象的访问，可是对象的移动要变的异常复杂。如下图：
对于真实的jvm到底是那种情况。不懂！举个例子讨论下：
public class yy {
private int t=9;
private int y=9;
private Integer t1=new Integer(9);
private Integer t2=new Integer(9);
public static void main(String args[]){
yy y=new yy();
System.out.println(y.t2==y.t1);//false
System.out.println(y.t==y.t1);//true
System.out.println(y.t==y.y);//true
}都是动态属性，成员变量。通过运行的结果，成员变量时原始类型到时候比较值，成员变量是引用类型的情况比较复杂。分两种情况，一种是原始类型和引用类型比较，是比较值。一种是引用类型与引用类型比较，是比较引用地址。分配情况不清楚。具体怎么分配。疑问很多。我发现想的越多，感觉越来越头晕！上面的也不知道说的是对还是不对，敬请大家指教！上面所有的都是针对成员变量来说的，不是针对对于局部变量，我觉的讨论原始类型和引用类型的时候还要分是成员变量，还是局部变量！因为两者内存的分配情况是不一样的了！期待高手们画图指导啊！
Integer t1=new Integer(9);
Test t=new Test();
我觉得问题不是出在到底是分配在栈上还分配在堆里。
问题出在：JAVA里对于变量本身的类型的不统一。（指针和原始变量长一样了）
Integer *t1=new Integer(9);
Test *t=new Test();
你可以很清楚地看到，t1,t只是保存着指向一个内存对象的【地址】，而w只是保存一个【值】9
System.out.println(t.i==w);
你的这个比较只是比较的他们的值，所以他们是相等的，无论他们分别在哪里。
对于这两个变量有一点是肯定的就是 &(t.i) ==&w 是不相等的。
System.out.println(y.t2==y.t1);//false
这个FALSE其实你是在比较两个指向不同integer对象的指针。
System.out.println(y.t==y.t1);//true
System.out.println(y.t==y.y);//true
这个因为的结果是因为JAVA 1.6的拆包装包机制吧，你的y.t1对象被拆包了，变成了一个值了。
PS:我觉得楼主的问题还是在没有弄清楚变量里到底装的是什么。
对于int w=9来说，w变量里装的是9。对于Test t = new Test();
t1变量里装的是指向Test对象的地址（我假设是0x500）。但是t之中i的变量装的值是9。
而==操作符只是比较两个变量中所装的值而已。
正在学Java ，不是说Java里没有指针吗？ 怎么觉得到处都是指针 ！！
在大家的帮助下，貌似对些问题，慢点慢点理解。谈谈我的一个疑问，
class Test{
private int i=9;
private int j=9;
private Integer t1=new Integer(9);
private Integer t2=new Integer(9);
public static void main(String args[]){
Test t=new Test();
System.out.println(t.i==t.j);//true
System.out.println(t.i==w);//true
System.out.println(t.t1==t.t2);//false
引用最先前的那个例子。很明显开始我考虑问题忽视了java的拆箱，装箱机制，对与基本类型比较的时候，内部应该会将对象自动拆箱，==就是比较值的相等。这就是上面的
System.out.println(t.i==w);//true & 这个的解释,而最后那个System.out.println(t.t1==t.t2);//false
很明显这是对象间的比较，明显比较引用，明显不可能相等。所以为false.
我现在有个疑问，我看到很多书上都这么说，对于
编译器先处理int w = 9；首先它会在栈中创建一个变量为w的引用，然后查找有没有字面值为9的地址，没找到，就开辟一个存放9这个字面值的地址，然后将f指向9的地址。接着处理int f = 9；在创建完f的引用变量后，由于在栈中已经有9这个字面值，便将f直接指向9的地址。这样，就出现了w与f同时均指向9的情况。如果说原始类型的变量是自己持有值，而不在持有引用，指向别的值。有疑问？
第二个疑问也是我对java方法传参的疑问，下面列子：
今天看了一下别人到blog关于java方法中到参数传值到问题，突然仔细想了一下，原来自己一直也没弄懂。看下面到例子：
public class cl{
int a=3,b=4;
void swap(int a,int b){
System.out.println("=====inner a======="+a);
public static void main(String args[]){
cl c=new cl();
c.swap(c.a,c.b);
//形参，与实参。
System.out.println(c.a);
public class cl{
int a=3,b=4;
void swap(int a,int b){
System.out.println("=====inner a======="+a);
public static void main(String args[]){
cl c=new cl();
c.swap(c.a,c.b); //形参，与实参。
System.out.println(c.a);
}程序运行到结果是：
=====inner a=======9；
这个是参数直接传递基本类型的例子。
还有一个例子是参数传递对象的：
public void call(Test t) {
Test t2 = new Test();
t2.setName("cba');
t.setName("abc");
public static void main(String[] arg) {
Test obj = new Test();
call (obj) ;
System.out.println("obj"+obj.getName());
public void call(Test t) {
Test t2 = new Test();
t2.setName("cba');
t.setName("abc");
public static void main(String[] arg) {
Test obj = new Test();
call (obj) ;
System.out.println("obj"+obj.getName());
} 程序运行到结果是：
两个传参一个是基本类型，一个对象，总结网上很多说法，但是还是没有清楚到给出它们的
底层内存分配运行是的状况。但是有如下共识：
对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
方法体内对参数进行运算，不影响原有变量的值。
方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
思考java参数传递时具体到内存分配了！
没有看完整个帖子，但是楼主犯了一些常识性的错误。
例如最后一个回复里面的
引用int w=9;& int f=9;&&
编译器先处理int w = 9；首先它会在栈中创建一个变量为w的引用，然后查找有没有字面值为9的地址，没找到，就开辟一个存放9这个字面值的地址，然后将f指向9的地址。接着处理int f = 9；在创建完f的引用变量后，由于在栈中已经有9这个字面值，便将f直接指向9的地址。这样，就出现了w与f同时均指向9的情况。
9对于编译器来说是常量，所以不会查找所谓的"9这个字面值", 而是直接把9入栈，然后弹出来保存在局部变量w， 然后重复的动作做f， 而比较的时候，把w,f分别入栈，然后弹出两个int值做比较。
看这两个变量的声明：
//把常量9入栈
istore_2 //弹出栈顶值(9)，存入局部变量2
9 //把常量9入栈
istore _3//弹出栈顶值(9)，存入局部变量3
看字节码就一目了然，也不会出现这样的理解：引用就出现了w与f同时均指向9的情况
最后，对于 == 的比较， 虚拟机都是直接弹出栈顶的两个值，不管是引用还是原始类型，直接比较。
RednaxelaFX 写道最近项目周期很紧所以暂时回复不了什么，下下周应该能稍微解脱一两天吧，到时候画些图来说明这个。大家有兴趣讨论的请先踊跃发表见解哦～
先简单写几句：
1、一定要留意，JVM规范所规定的“概念中的JVM”与实际的JVM实现是可以有差异的。所以请区分清楚“堆”、“栈”在概念中与实际实现中的不同。我猜多数Java程序员更关心（或者说更有用）的是概念中的JVM的状况，但请千万不要想当然的认为实际上也必须要那样实现。
不过，作为一种现象，我们可以观察到用解释器实现的JVM会比用JIT编译器/混合模式方式实现的JVM要更接近于概念中的JVM。
2、请留意，“地址”、“指针”、“引用”等是不同抽象层次的概念，并不等价。
·引用可以用指针来实现，也可以用handle（一般翻译为“句柄”？总之很怪）来实现；
·指针里可以直接包含地址，也可以包含地址的某种映射关系（例如HotSpot中的compressedOop）；
·地址可以是不同意义上的地址，在常见的Linux、Windows等现代操作系统上一般有虚拟内存系统，因而所谓“地址”在这里一般指虚拟内存的地址而不是所谓的“物理内存地址”。“物理内存”是一个经常被滥用、误用的词，也要注意判断。
后面几点没有特别说明的话都是针对概念上的JVM而言的。
3、Java是一种静态与动态类型相结合的强类型语言，表现在：
·Java的变量有类型，值也有类型，而且变量与值的类型并不需要精确一致，只要满足赋值匹配的约束即可；
·Java变量的类型可以是原始类型或引用类型的，其中引用类型又包括类类型、接口类型与数组类型；
·Java值的类型也可以是原始类型或引用类型的，其中引用类型的值包括指向类的实例的引用或者指向数组实例的引用；
·Java的类型系统中，所有与原始类型相关的操作都可以在Java源码编译时完成类型检查，并且在运行时不需要做额外的检查来保证类型安全；而引用类型的相关操作中有部分带有运行时检查的必要，例如强制向下类型转换、对元素为引用类型的数组的元素赋值，等等；
·Java中虚方法的实际调用目标在Java源码编译时无法确定，概念上需要在运行时根据值的实际类型来分派，与上一条提到的动态类型检查一起表现了Java的动态性。
4、原始类型的变量如果是成员变量，那么它的存储空间就正好是其所在对象中的一部分，是在Java堆上的。引用类型的变量……嗯回头有空画图了再详细说。
5、原始类型变量之间的==与!=所做的是相等性比较——值是否相等，而引用类型变量之间的==与!=做的是同一性比较——是否指向同一对象。其实如果可以理解“引用”的本质就是多了一个间接层的话，这个非常好理解，因为引用间的比较实质上也是值比较。这跟“Java中方法调用的参数传递全部是按值传递”底下的道理是一样的。
6、如果把方法的代码看作它的“静态”部分，而把一次方法调用需要记录的临时数据看做它的“动态”部分，那么每个方法的代码是只有一份的，存储于JVM的方法区中；每次某方法被调用，则在该调用所在的线程的的Java栈上新分配一个栈帧，用于存放临时数据，在方法返回时栈帧自动撤销；
7、Java程序中没有全局变量的概念。相似的概念只有“静态变量”。概念上它也是存储在方法区里的。
于是……等我回头画图吧，呵呵 ^_^
撒迦，你的图呢？如何在vba中设置一个全局变量，使得所有窗体都可以使用这个变量？
如何在vba中设置一个全局变量，使得所有窗体都可以使用这个变量？&
回复讨论(解决方案)
在模块里定义变量：
dim&w1&as&string
public&w1&as&string
21:31&&&[]
做项目的时候，需要权限管理。我就想用个全局变量来标志每个登陆用户的权限，所以就需要一个在所有CPP文件中都能访问到的全局变量。请问怎么申明，然后怎么使用？谢谢
回复讨论(解决方案)
qt没用过，
在一个头文件中&extern&变量类型&变量名，在cpp中声明
-16:05&&&[]
我做的一个简单登陆验证程序，设置全局变量&users&记录登陆人的ID。然后其他窗体根据useers的记录来判断是否允许进行操作。现在只有登陆密码校验的窗体能直接使用这个变量赋值，其他窗体里使用就会提示“缺少过程，不是变量”。请问这是会是什么原因？
回复讨论(解决方案
-19:10&&&[]
如何声明一个项目级变量a，使得a在本项目的所有代码文件中可以共享
回复讨论(解决方案)
楼主说的是全局变量么？
public&a&as&string&&&&&
public&a&nbsp
13:57&&&[]
，VAR下面定义，不过在别的窗体中用的时候还是要引用主窗体的单元。
哦，知道了&&哪我定义一个公用pas&引用了在&附值&是吧
对，就叫它UnitGlobal.pas吧，吼吼
19:47&&&[]
如题&& 如何在基于对话框中定义全局变量
在Stdafx.H里申明
extern&int&pData[5];
在Stdafx.cpp里定义
int&&pData[5]={0};
这样定义使用对吗对吗
17:57&&&[]
公共单元中定义全局变量，和公共函数;
3、在其它单元、窗体中加入Uses&MyOwn。
4、在其它单元、窗体中即可，直接使用全局变量，和公共函数。
我做了三个窗体，比如Form1中有个变量data1,在Form2中引用了这个变量，而在Form3中我想用Form2
-19:47&&&[]
我遇到一个问题，我需要在整个工程里面随时修改一个变量的值,其他所有包含这个变量文件的变量都随之改变。
哪位高手能给出一个简单的例子？
我想了一天都没有找到合适的方案，涉及到的都是两个文件使用全局变量。
请高手指教，必有重谢！
回复讨论(解决方案)
lz&没搞清楚全局变量的用法
-19:12&&&[]
回复讨论(解决方案)
是不是引用的类库不足呢？
没人知道吗？一个FORM向另一个FORM传值应该用什么方法？
终于明白了。定义静态变量。
静态变量可以了么,学习一下
可以使用全局变量的方式传给数据库处理,但不推荐这样使用,因为这样容易造成业务逻辑层与数据访问层相互引用.你可以
-11:40&&&[]
&web应用中有个session对象可以保存全局变量，&请问一下j2se桌面应用中如何设置一个全局变量，供其他的JFrame直接获取。。。
&业务描述：用户登入，记录用户登入信息，输入用户名后，我加载了一个系统托盘，没有显示FrmMain窗口，可以通过点击右下角图标
-16:37&&&[]
&1.java&文件里&定义一个变量&比如：布尔型的:&&FLAG
&在&2.java里也可以使用
也就是说，这个变量&FLAG&可以在整个工程内都有效呢？
-00:01&&&[]
会有冲突么?&会不会自动生成本地存储，使得多个进程各自对于该全局变量拥有一个实例?
回复讨论(解决方案)
一个dll函数，有一个全局变量，dll被多个进程使用时，互不干扰。
一个dll函数，有一个全局变量，dll被多个线程使用时，使用同一个全局变量。
非共享的变量，每个进程
-10:56&&&[]