JVM高并发、JMM模型

1、JMM模型

Java内存模型 JMM
就是为了解决多线程场景下并发问题的一个重要规范

CPU 和缓存的一致性问题
CPU 执行应用程序 SparkApp，仅仅只负责执行
Data：在计算的物理内存里面
他们是处在不同的地方，随着技术的发展，CPU的速度是大于内存的
高速的CPU去内存读和写，内存肯定是跟不上的

所以在CPU 和物理内存 之间有个 高速缓存
一级缓存
二级缓存
三级缓存

2、高并发三原则

并发编程三原则：
1、原子性 一个操作再CPU当中，不可以中断，要么全部过程执行完，要么失败
2、可见性 A线程改变的值，B线程是可以看到的
3、有序性 代码编译之后的重排，有先后顺序执行

可见性：volatile，但不保证原子性
多个线程对主内存的共享变量的操作是可见的

原子性：要么同时成功，要么同时失败
先编译下class文件，查看字节码
借助于JUC下面的 Atomic 来解决

package com.ruozedata.jvm;

import java.util.concurrent.atomic.AtomicInteger;

public class JMMDemo {
     
    public static void main(String[] args) {
     
        final Data data=new Data();
        
        //这段代码 测试可见性
//        new Thread(new Runnable() {
     
//            public void run() {
     
//                System.out.println(Thread.currentThread().getName());
//                try {
     
//                    Thread.sleep(2000);
//                } catch (InterruptedException e) {
     
//                    e.printStackTrace();
//                }
//                data.updateNumber();
//                System.out.println(Thread.currentThread().getName()+" number= "+data.number);
//            }
//        },"JMMDemo").start();
//
//        //第二个线程
//        while (data.number==0){
     
//
//        }
//        System.out.println(Thread.currentThread().getName()+" number= "+data.number);


        // 这段代码测试 原子性
        for (int i=0;i<10;i++){
     
            new Thread(new Runnable() {
     
                public void run() {
     
                    for (int j=0;j<10000;j++){
     
                        data.increment();
                        data.incrementAtomic();
                    }
                 }
            },"JMMDemo"+i).start();
        }

        while (Thread.activeCount()>2){
     
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+" number= "+data.number);
        System.out.println(Thread.currentThread().getName()+" number= "+data.integer.get());


    }
}


class Data{
     
    volatile int number=0;  //volatile 如果没有加这个关键字，第二个线程 都没有执行

    public  void  updateNumber(){
     
        this.number=100;
    }

    public  void increment(){
       //synchronized也可以保证原子性
        number++;
    }

    AtomicInteger integer=new AtomicInteger();  // 借助	JUC下面的 Atomic 来解决
    public void incrementAtomic(){
     
        integer.getAndIncrement();
    }

}