java栈和堆在多线程运行时的访问

迈不过友情╰ 2024-02-18 14:57 27阅读 0赞

## 阅读目录 ##

*  [一、前言][Link 1]
 *  [二、JAVA中的内存模型][JAVA]
 *  [ 三、多线程访问共享内存情况][Link 2]
 *  [四、实例说明][Link 3]

## 一、前言 ##

最近在工作上用到了一个静态方法，跟同事交流的时候，被一个问题给问倒了，只怪基础不扎实...

问题大致是这样的，“在多线程环境下，静态方法中的局部变量会不会被其它线程给污染掉？”；

我当时的想法：方法中的局部变量在运行的时候，是存在JAVA栈中的，方法运行结束，局部变量也就都弹光了，理论上单线程的话是不会有问题的，我之所以不知道，是因为不清楚在JAVA内存模型中，一个线程对应一个栈，还是多个线程共享一个栈...

其实如果知道每个线程都有一个自己的JAVA栈的话，问题也就很清楚了，不会被其它线程给污染掉；

当然，问题并不能止于此，这个问题已经暴露出自己对这方面比较薄弱，因此打算对JAVA内存模型和多线程并发问题做个小小总结；

## 二、JAVA中的内存模型 ##

程序运行的时候，内存主要由以下部分组成：

1.  堆：所有线程共享一个堆；存放的都是new 出来的对象；由垃圾回收器回收；
2.  方法区：所有线程共享一个方法区；里面存放的内容有点杂，可以认为是除堆和栈中的其它东西（如类信息，静态变量，常量，代码等）；Java虚拟机规范规定可以不对方法区进行垃圾回收，当并不是不回收，主要看具体虚拟机的实现，比如可以回收一些废弃常量和无用的类；
3.  程序计数器：也叫PC,存放下一条指令所在单元的地址的地方;
4.  JAVA栈：每个线程都有一个自己的JAVA栈;存放的一般是方法的局部变量，方法出口信息等；方法调用过程中，自动压栈出栈；ps：栈空间大小是有限制的；
5.  本地方法栈：与JAVA栈类似，区别是使用的对象不一样，本地方法栈是给Native方法使用的，JAVA栈是给JAVA方式使用的；

附一张图片，会对java虚拟机有个整体的认识；

图片来自[https://www.zybuluo.com/867976167/note/51071][https_www.zybuluo.com_867976167_note_51071]

![879896-20160126141904442-1709398963.jpg][]

## 三、多线程访问共享内存情况 ##

当多个线程执行同一个方法的时候，

什么时候可能会出现异常结果：

多个线程共享一块内存区域，在不加任何保护情况下，对其操作；

什么时候可能会得到正确的结果：

不使用共享内存，每个线程内存空间相互独立；

多线程共享一块内存区域，但是对这块共享区域加锁访问；

## 四、实例说明 ##

情况一（多个线程共享一块内存区域，在不加任何保护情况下，对其操作）：

写一个含静态方法的类，求和，方法内用了一个静态全局s（多个线程可以同时访问）：

![复制代码][copycode.gif]

package com.pichen.java.static_;
    
    public class StaticTest {
    
        private static int s = 0;
        public static int sum(int n){
            s = 0;
            for(int i = 0; i <= n; i++){
                s += i;
                
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return s;
        }
    }

![复制代码][copycode.gif]

写一个Thread，调用上面的静态方法：

![复制代码][copycode.gif]

package com.pichen.java.static_;
    
    public class ThreadCount implements Runnable{
    
    
        @Override
        public void run() {
            while(true){
                System.out.println(Thread.currentThread().getName() +":" +StaticTest.sum(100));
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
        }
    
    }

![复制代码][copycode.gif]

写个Main函数，起三个线程，观察运行结果，基本都是错误的：

![复制代码][copycode.gif]

package com.pichen.java.static_;
    
    
    public class Main {
    
        public static void main(String[] args) {
    
            ThreadCount t1 = new ThreadCount();
            new Thread(t1).start();
            
            ThreadCount t2 = new ThreadCount();
            new Thread(t2).start();
            
            ThreadCount t3 = new ThreadCount();
            new Thread(t3).start();
        }
    }

![复制代码][copycode.gif]

运行结果不符合预期：

![复制代码][copycode.gif]

Thread-0:13968
    Thread-1:13968
    Thread-2:13968
    Thread-0:13033
    Thread-1:13033
    Thread-2:13033 Thread-1:14725 Thread-0:14725

![复制代码][copycode.gif]

原因：多个线程同时对静态全局变量s进行操作导致；

ps：这里的例子是静态全局变量s，其实有很多种情况会引起结果异常问题，如在main方法中new出了一个对象，new出来的对象是存放在堆中的，多个线程共享，此时如果多线程同时操作该对象的话，也是有可能产生错误结果；

情况二（不使用共享内存，每个线程内存空间相互独立）：

修改静态sum方法，使用局部变量s，如下：

![复制代码][copycode.gif]

package com.pichen.java.static_;
    
    public class StaticTest {
    
        private static int s = 0;
        public static int sum(int n){
            int s = 0;
            for(int i = 0; i <= n; i++){
                s += i;
                
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return s;
        }
    }

![复制代码][copycode.gif]

运行程序，结果正确：

![复制代码][copycode.gif]

Thread-1:5050
    Thread-0:5050
    Thread-2:5050
    Thread-0:5050
    Thread-2:5050
    Thread-1:5050
    Thread-0:5050

![复制代码][copycode.gif]

情况三（多线程共享一块内存区域，但是对这块共享区域加锁访问）：

![复制代码][copycode.gif]

package com.pichen.java.static_;
    
    public class StaticTest {
    
        private static int s = 0;
        public synchronized static int sum(int n){
            s = 0;
            for(int i = 0; i <= n; i++){
                s += i;
                
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return s;
        }
    }

![复制代码][copycode.gif]

运行程序，结果正确：

![复制代码][copycode.gif]

Thread-1:5050
    Thread-0:5050
    Thread-2:5050
    Thread-0:5050
    Thread-2:5050
    Thread-1:5050 Thread-0:5050

![复制代码][copycode.gif]

[Link 1]: http://www.cnblogs.com/chenpi/p/5159558.html#_label0
[JAVA]: http://www.cnblogs.com/chenpi/p/5159558.html#_label1
[Link 2]: http://www.cnblogs.com/chenpi/p/5159558.html#_label2
[Link 3]: http://www.cnblogs.com/chenpi/p/5159558.html#_label3
[https_www.zybuluo.com_867976167_note_51071]: https://www.zybuluo.com/867976167/note/51071
[879896-20160126141904442-1709398963.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/18cc6c6397a64863b30568f9d59fe369.png
[copycode.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/59ac62a52594405da132cbfafc0fb80c.png