Java~多线程关键字volatile和synchronized的特性比较

最新推荐文章于 2022-01-10 15:40:51 发布

Listen-Y

最新推荐文章于 2022-01-10 15:40:51 发布

阅读量641

点赞数 4

分类专栏： Java多线程 Java 文章标签：多线程 java

本文链接：https://blog.csdn.net/Shangxingya/article/details/108922879

版权

Java 同时被 2 个专栏收录

104 篇文章 11 订阅

订阅专栏

Java多线程

40 篇文章 0 订阅

订阅专栏

文章目录

比较

线程安全主要就是原子性和可见性俩个方面, Java中的同步机制就是围绕这俩个方面来确保线程的安全.

通过使用volatile关键字，是强制的从公共内存中读取变量的值, 是线程同步的轻量级实现, 所以volatile性能肯定比synchronized要好，并且 volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。
随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
volatile能保证数据的可见性，但不能保证原子性;而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
volatile可以依托操作系统的内存屏障防止这个数据的指令重排序（因为操作系统指令级别也会有指令优化，所以直接使用操作系统的内存屏障实现）。在有数据依赖关系上的指令是禁止重排序的，而synchronize保证同步代码块，所以即使出现指令重排序但是不会有异常出现。

volatile的非原子特性

服务类

public class ServiceAdd {

    volatile public int count = 0;

    public void add() {
        this.count++;
    }

}

运行类

public class Run {

    public static void main(String[] args) throws InterruptedException {
        ServiceAdd serviceAdd = new ServiceAdd();

        Thread[] threads = new Thread[100];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        serviceAdd.add();
                    }
                }
            };
        }
        for (int i = 0; i < 100; i++) {
            threads[i].start();
        }
        for (Thread t : threads
             ) {
            t.join();
        }
        System.out.println(serviceAdd.count);
    }

}

运行结果

关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是:如果修改实例变量中的数据，比如i++，也就是i=i+1，则这样
的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下:
1）从内存中取出i的值;
2）计算i的值;
3）将i的值写到内存中。
假如在第2步计算值的时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized 关键字，所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。
用图来演示一下使用关键字volatile时出现非线程安全的原因。变量在内存中工作的过
在多线程环境中，use和asign是多次出现的，但这一操作并不是原子性，也就是在read和 load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果会和预期不一样，也就出现了非线程安全问题。
对于用volatile修饰的变量，JVM虚拟机只是保证从主内存加载到线程工作内存的值是最新的，例如线程1和线程2在进行read和 load的操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。也就是说，volatile关键字解决的是变量读时的可见性问题，但无法保证原子性，对于多个线程访问同一个实例变量还是需要加锁同步。

使用原子类来进行++操作

原子操作是不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子(atomic）类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全( thread-safe)。

服务类

public class ServiceAtomic {

    public AtomicInteger count = new AtomicInteger(0);

    public void add() {
        count.incrementAndGet();
    }

}

运行类

public class Run2 {

    public static void main(String[] args) throws InterruptedException {
        ServiceAtomic atomic = new ServiceAtomic();

        Thread[] threads = new Thread[100];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        atomic.add();
                    }
                }
            };
        }
        for (int i = 0; i < 100; i++) {
            threads[i].start();
        }
        for (Thread t : threads
        ) {
            t.join();
        }
        System.out.println(atomic.count);
    }

}

运行结果

原子类也不一定是线程安全的

因为原子类只是单纯保证了我运行其的某个方法是原子的, 但是在我们自己写的代码中, 并没有保证原子性, 所以即使我们使用了原子类但是在我们自己写的代码面前再加上一点逻辑的话, 就还会有线程安全问题
服务类

public class ServiceAdd2 {

    public AtomicInteger count = new AtomicInteger(0);

    public void addOne() {
        System.out.println("执行加一: " + count.addAndGet(1));
    }

    public void addHundred() {
        System.out.println("执行加一百: " + count.addAndGet(100));
    }

}

运行类

public class Run3 {

    public static void main(String[] args) throws InterruptedException {
        ServiceAdd2 serviceAdd2 = new ServiceAdd2();
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread() {
                @Override
                public void run() {
                    serviceAdd2.addOne();
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    serviceAdd2.addHundred();
                }
            };
        }
        for (Thread t : threads
             ) {
            t.start();
        }
        for (Thread t : threads
             ) {
            t.join();
        }
    }
}