java内存详解

2、JAVA中的内存模型

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

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

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

图片来自https://www.zybuluo.com/867976167/note/51071

 3、多线程访问共享内存状况

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

何时可能会出现异常结果：

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

何时可能会获得正确的结果：

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

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

4、实例说明

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

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

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;
    }
}

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

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();
            }
        }
        
    }

}

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

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();
    }
}

运行结果不符合预期：

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

 缘由：多个线程同时对静态全局变量s进行操做致使；

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

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

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

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;
    }
}

运行程序，结果正确：

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

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

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;
    }
}

@author   风同样的码农
@blog_urlhttp://www.cnblogs.com/chenpi/

运行程序，结果正确：

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