thread11 - volatile

package com.neutron.t11;

import java.util.ArrayList;
import java.util.List;

/**
 * 讲解内容：volatile关键字
 *   volatile关键字，会使1个变量在多个线程中可见。
 *   使用volatile将会强制所有的线程都去堆内存中读取running的值
 *   volatile并不能保证多个线程共同修改running变量所带来的数据不一致性的问题，volatile不能代替synchronized
 *
 *   volatile保证可见性，但是不保证一致性
 *   synchronized保证原子性(数据一致)和可见性，但是比volatile要重，因此能用volatile就不用synchronized
 */
public class T11 {

    volatile int count = 0;

    public /*synchronized*/ void mm() {
        for (int i = 0; i < 1000; i++) {
            count ++;
        }
    }

    /**
     预期结果：
        count: 10000
     运行结果：
        count: 9474
        开启10个线程，每个线程执行1000次，预期结果是10000，但是实际上是小于10000的任意数值
         1.volatile关键字修饰保证线程的可见性
           线程1执行加到100，count=100；线程2执行到count=101，线程3执行到120，线程2执行到102，由于线程可见，
           线程3执行到120，那么此时公共的count=120，线程2执行到102停止，那么线程可见把120修改为102，
           线程4执行，那么本来应该是120的数据，此时是102，线程4从102开始累加
           以上只是其中的某种可能解释，数据可能不是确切的100多，可能1位数，2位数时候就这样执行的。
         那么如何结果这个问题呢？
           mm方法加上synchronized修饰，保证操作的原子性

     */
    public static void main(String[] args) {
        T11 t11 = new T11();

        List<Thread> threads = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t11::mm, "thread" + i));
        }

        threads.forEach(o -> o.start());

        threads.forEach((o) -> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("count: " + t11.count);
    }
}