Java多线程之volatile关键字

volatile关键字

import java.util.concurrent.TimeUnit;

/**
 * volatile
 * volatile 比 synchronized 效率高很多
 * 能用volatile就不要用synchronized，很多并发容器都用了volatile
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 */
public class VolatileTest {

    /*volatile*/ boolean running = true;
    //对比有无volatile的情况下，执行情况。

    void m() {
        System.out.println(Thread.currentThread().getName() + " m start ...");
        while (running) {
            try {
                TimeUnit.SECONDS.sleep(1); //没加volatile，加了休眠，有可能会让线程通信一下。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " while ...");
        }
        System.out.println(Thread.currentThread().getName() + " m end ...");
    }

    public static void main(String[] args) {
        VolatileTest test = new VolatileTest();
        new Thread(() -> {
            test.m();
        }, "线程1").start();
        //new Thread(test :: m, "线程1").start(); //这种写法更简洁

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        test.running = false; //改变running的值，停止死循环

        //每个线程都有自己的一块内存区域，线程1拿到running这个值，会去运算，挡住内存running的值发生变化，
        // 就没空去主内存读取值，
        //当加了volatile这个值，主内存running这个值发生变化时，会通知线程1(缓存过期通知)这个running值发生了变化，再去读一次。
    }

}

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

/**
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 *
 * synchronized保障原子性和可见性
 */
public class VolatileTest1 {

    volatile int count = 0; //光可见性是没用的，并不保证原子性

    //还是需要加synchronized关键字
     void add() {
        for(int i=0; i<1000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {

        VolatileTest1 test = new VolatileTest1();
        List<Thread> threads = new ArrayList<>(10);
        //添加线程
        for (int i=0; i<10; i++) {
            threads.add(new Thread(test :: add, "线程" + i));
        }
        //唤醒线程
        threads.forEach(t -> t.start());

        threads.forEach(t -> {
            try {
                t.join(); //主线程等待子线程完成在执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(test.count);
    }

}