第七章 JVM对高效并发的支持

一. Java内存模型与内存间的交互操作

1. Java内存模型

1.1 概念

1.2 示意图

1.3 规则

2. 内存交互

2.1 操作名词

2.2 操作流程

2.3 操作的规则

二. volatile(❤❤❤)

1. 多线程可见性

2. volatile

2.1 不安全演示

package src.com.yh.jvm.parallel;

/**
 * 演示volatile多线程下不安全
 */
public class A {
    //计数
    private volatile int count;

    public int getCount() {
        return count;
    }

    /**
     * 加一操作
     */
    public void addOne() {
        count++;
    }
}

package src.com.yh.jvm.parallel;

/**
 * 线程,对A的count进行累加操作
 */
public class MyThread implements Runnable {
    private A a = null;
    private String name = "";

    public MyThread(A a, String name) {
        this.a = a;
        this.name = name;
    }

    /**
     * 线程:对对象A的count累计操作
     */
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            a.addOne();
        }
        System.out.println("thread_name:" + name + " is game over--->");
    }
}

package src.com.yh.jvm.parallel;

public class Test1 {
    public static void main(String[] args) throws Exception {
        A a = new A();
        Thread t1 = new Thread(new MyThread(a, "t1"));
        Thread t2 = new Thread(new MyThread(a, "t2"));

        t1.start();
        t2.start();

        t1.join();
        t2.join();


        System.out.println("方法变量A.count=" + a.getCount());
    }
}

业务上,两个线程对方法变量A的count属性进行累加操作,如果线程安全那么待两线程结束运行后该值应该为2000
下面为多次执行结果图

可见,最后结果不为2000,并且每次执行结果不可预估

如果给加一方法添加synchronized 锁

package src.com.yh.jvm.parallel;

/**
 * 演示volatile多线程下不安全
 */
public class A {
    //计数
    private volatile int count;

    public int getCount() {
        return count;
    }

    /**
     * 加一操作
     */
    public synchronized void addOne() {
        count++;
    }
}

3. volatile使用场景

三. 指令重排原理和规则

1. 指令重排原理

2. 指令重排规则

五. 线程安全处理

六. 锁优化