5.juc学习进程（五、synchronized、volatile区别）

最新推荐文章于 2024-04-11 10:51:44 发布

渺小的码字员

最新推荐文章于 2024-04-11 10:51:44 发布

阅读量260

点赞数

分类专栏： JUC 文章标签：学习 jvm java

本文链接：https://blog.csdn.net/qq_42796729/article/details/127385759

版权

JUC 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1) volatile主要应用在多个线程对实例变量更改的场合，刷新主内存共享变量的值从而使得各个线程可以获得最新的值，线程读取变量的值需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。另外，synchronized还会创建一个内存屏障，内存屏障指令保证了所有CPU操作结果都会直接刷到主存中（即释放锁前），从而保证了操作的内存可见性，同时也使得先获得这个锁的线程的所有操作

2) volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。 volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞，比如多个线程争抢 synchronized锁对象时，会出现阻塞。

3) volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性，因为线程获得锁才能进入临界区，从而保证临界区中的所有语句全部得到执行。

4) volatile标记的变量不会被编译器优化，可以禁止进行指令重排；synchronized标记的变量可以被编译器优化。

1、synchronized和volatile区别

个人理解JMM：Java Memory Model(Java内存模型)，根据并发过程中如何处理、可见性、原子性和有 序性这三个特性而建立的模型。

可见性：JMM提供了volatile变量定义、final、synchronized块来保证可见性。

原子性：个人理解是如果执行，就执行完，synchronized块来保证。

有序性：觉得有序是相对性的，根据从哪个线程观察，volatile和synchronized保证线程之间操作的有序性。

指令重排：处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证各个语句的执行顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

JMM处理过程：JMM是通过禁止特定类型的编译器重排序和处理器重排序来为程序员提供一致的内存可
见性保证。例如A线程具体什么时候刷新共享数据到主内存是不确定的，假设我们使用了同步原语
(synchronized，volatile和final),那么刷新的时间是确定的。

每个线程都有一个自己的本地内存空间–虚拟机栈线程空间。线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作
对该变量操作完后，在某个时间再把变量刷新回主内存，所以线程A释放锁后会同步到主内存，线程B获取锁后会同步主内存数据，即“A线程释放锁–B线程获取锁”可以实现A，B线程之间的通信

假设本地内存A和B有主内存中共享变量x的副本，初始时这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。然后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

重点：

1. volatile主要应用在多个线程对实例变量更改的场合，刷新主内存共享变量的值从而使得各个线程
可以获得最新的值，线程读取变量的值需要从主存中读取；synchronized则是锁定当前变量，只有
当前线程可以访问该变量，其他线程被阻塞住。另外，synchronized还会创建一个内存屏障，内存
屏障指令保证了所有CPU操作结果都会直接刷到主存中（即释放锁前），从而保证了操作的内存可
见性，同时也使得先获得这个锁的线程的所有操作

2. volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。

3. volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞，比如多个线程争抢
synchronized锁对象时，会出现阻塞。

4. volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性，因为线程获得锁才能进入临界区，从而保证临界区中的所有语句全部得到执行。

5. volatile标记的变量不会被编译器优化，可以禁止进行指令重排；synchronized标记的变量可以被编译器优化。

2、synchronized锁粒度、模拟死锁场景；

synchronized：具有原子性，有序性和可见性

粒度：对象锁、类锁

三大性质总结

2.1、三大性质简介

在并发编程中分析线程安全的问题时往往需要切入点，那就是两大核心：JMM抽象内存模型以及 happens-before规则

三条性质：原子性，有序性和可见性。关于synchronized和volatile已经讨论过了，就想着将并发编程中这两大神器在原子性，有序性和可见性上做一个比较，当然这也是面试中的高频考点，值得注意。

2.2、原子性

原子性是指一个操作是不可中断的，要么全部执行成功要么全部执行失败，有着“同生共死”的感觉。及时在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程所干扰。我们先来看看哪些是原子操作，哪些不是原子操作，有一个直观的印象：

int a = 10; //1
a++; //2
int b=a; //3
a = a+1; //4

上面这四个语句中只有第1个语句是原子操作，将10赋值给线程工作内存的变量a,

而语句2（a++），实际上包含了三个操作：1. 读取变量a的值；2：对a进行加一的操作；3.将计算后的值再赋值给变量a，

而这三个操作无法构成原子操作。对语句3,4的分析同理可得这两条语句不具备原子性。当然，java内存模型中定义了8种操作都是原子的，不可再分的。

1. lock(锁定)：作用于主内存中的变量，它把一个变量标识为一个线程独占的状态；
2. unlock(解锁):作用于主内存中的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
3. read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便
后面的load动作使用；
4. load（载入）：作用于工作内存中的变量，它把read操作从主内存中得到的变量值放入工作内存中
的变量副本
5. use（使用）：作用于工作内存中的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚
拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；
6. assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎接收到的值赋给工作内存的变
量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
7. store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送给主内存中以便随后
的write操作使用；
8. write（操作）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的
变量中。

上面的这些指令操作是相当底层的，可以作为扩展知识面掌握下。那么如何理解这些指令了?比如，把一个变量从主内存中复制到工作内存中就需要执行read,load操作，将工作内存同步到主内存中就需要执行 store,write操作。注意的是：java内存模型只是要求上述两个操作是顺序执行的并不是连续执行的。也就是说read和load之间可以插入其他指令，store和writer可以插入其他指令。比如对主内存中的a,b进行访问就可以出现这样的操作顺序：read a,read b, load b,load a。

由原子性变量操作read,load,use,assign,store,write，可以大致认为基本数据类型的访问读写具备原子性（例外就是long和double的非原子性协定）

synchronized

上面一共有八条原子操作，其中六条可以满足基本数据类型的访问读写具备原子性，还剩下lock和 unlock两条原子操作。如果我们需要更大范围的原子性操作就可以使用lock和unlock原子操作。尽管 jvm没有把lock和unlock开放给我们使用，但jvm以更高层次的指令monitorenter和monitorexit指令开放给我们使用，反应到java代码中就是---synchronized关键字，也就是说synchronized满足原子性。

volatile

我们先来看这样一个例子：

public class VolatileExample {
    private static volatile int counter = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++)
                        counter++;
                }
            });
            thread.start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter);
    }
}

开启10个线程，每个线程都自加10000次，如果不出现线程安全的问题最终的结果应该就是：10*10000 = 100000;可是运行多次都是小于100000的结果，问题在于 volatile并不能保证原子性，在前面说过 counter++这并不是一个原子操作，包含了三个步骤：1.读取变量counter的值；2.对counter加一；3.将新值赋值给变量counter。如果线程A读取counter到工作内存后，其他线程对这个值已经做了自增操作后，那么线程A的这个值自然而然就是一个过期的值，因此，总结果必然会是小于100000的。如果让volatile保证原子性，必须符合以下两条规则：

1. 运算结果并不依赖于变量的当前值，或者能够确保只有一个线程修改变量的值；

2. 变量不需要与其他的状态变量共同参与不变约束

2.3、有序性

synchronized

synchronized语义表示锁在同一时刻只能由一个线程进行获取，当锁被占用后，其他线程只能等待。因此，synchronized语义就要求线程在访问读写共享变量时只能“串行”执行，因此synchronized具有有序性。

volatile

在java内存模型中说过，为了性能优化，编译器和处理器会进行指令重排序；也就是说java程序天然的有序性可以总结为：如果在本线程内观察，所有的操作都是有序的；如果在一个线程观察另一个线程，所有的操作都是无序的。在单例模式的实现上有一种双重检验锁定的方式（Double-checked Locking）。代码如下：

public class Singleton {
    private Singleton() { }
    private volatile static Singleton instance;
    public Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这里为什么要加volatile了？我们先来分析一下不加volatile的情况，有问题的语句是这条：

instance = new Singleton();

这条语句实际上包含了三个操作：

1.分配对象的内存空间；

2.初始化对象；

3.设置instance指向刚分配的内存地址。但由于存在重排序的问题，可能有以下的执行顺序：

如果2和3进行了重排序的话，线程B进行判断if(instance==null)时就会为true，而实际上这个instance并没有初始化成功，显而易见对线程B来说之后的操作就会是错得。而用volatile修饰的话就可以禁止2和3 操作重排序，从而避免这种情况。volatile包含禁止指令重排序的语义，其具有有序性。

2.4、可见性

可见性是指当一个线程修改了共享变量后，其他线程能够立即得知这个修改。通过之前对synchronzed 内存语义进行了分析，当线程获取锁时会从主内存中获取共享变量的最新值，释放锁的时候会将共享变量同步到主内存中。从而，synchronized具有可见性。同样的在volatile分析中，会通过在指令中添加 lock指令，以实现内存可见性。因此, volatile具有可见性

2.5、. 总结

synchronized: 具有原子性，有序性和可见性；

volatile：具有有序性和可见性

3、基于synchronized的对象锁，类锁以及死锁模拟

分为对象锁和类锁

public class T {
    public void test1() throws Exception{
        synchronized(this){ //对象锁
            System.out.println(Thread.currentThread().getName()+"---test1 Doing");
            Thread.sleep(2000);
        };
    }
    public synchronized void test2() throws Exception{ //同test1方法
        System.out.println(Thread.currentThread().getName()+"--- test2 Doing");
        Thread.sleep(2000);
        test1();
    }
    public void testclass1() throws Exception{
        synchronized(T.class){//类锁
            System.out.println(Thread.currentThread().getName()+"---testclass1 Doing");
                    Thread.sleep(2000);
        };
    }
    public static synchronized void testclass2() throws Exception{ //同testclass1方法
        System.out.println(Thread.currentThread().getName()+"---testclass2 Doing");
                Thread.sleep(2000);
        testclass3();
    }
    public static synchronized void testclass3() throws Exception{ //同testclass1方法
        System.out.println(Thread.currentThread().getName()+"---testclass3 Doing");
                Thread.sleep(2000);
        testclass2();
    }
}

不同对象访问类锁测试：

public class clent {
	public static void main(String[] args) throws Exception {
		final CountDownLatch c=new CountDownLatch(1);
		new Thread(new Runnable(){
				@Override
				public void run() {
					T t1=new T();
					try {
						System.out.println(Thread.currentThread().getName()+"启动");
						c.await();
						t1.testclass3();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
		}).start();
		new Thread(new Runnable(){
			@Override
			public void run() {
				T t1=new T();
				try {
					System.out.println(Thread.currentThread().getName()+"启动");
					c.await();
					t1.testclass2();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
			c.countDown();
			/* 可以发现 类的synchronized一个线程获得不释放，其他线程就不能访问 通过Jconsole可以
			看到Thread0 一直在等待Thread1
			Thread-1启动
			Thread-1---testclass2 Doing
			Thread-0启动
			Thread-1---testclass3 Doing
			Thread-1---testclass2 Doing
			Thread-1---testclass2 Doing
			Thread-1---testclass3 Doing*/
	}

不同对象访问对象锁测试：

public class clent1 {
	public static void main(String[] args) {
	final CountDownLatch c=new CountDownLatch(1);
		new Thread(new Runnable(){
			@Override
			public void run() {
					T t1=new T();
					try {
						System.out.println(Thread.currentThread().getName()+"启动");
						c.await();
						t1.test1();
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				T t1=new T();
				try {
					System.out.println(Thread.currentThread().getName()+"启动");
					c.await();
					t1.test2();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
		c.countDown();
	}
	/* Thread-0启动
	Thread-0---test1 Doing
	Thread-1启动
	Thread-1--- test2 Doing
	*/
}

同一个对象，多个线程访问对象锁测试：

public class client2 {
	public static void main(String[] args) {
		final CountDownLatch c = new CountDownLatch(1);
		final T t1 = new T();
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println(Thread.currentThread().getName() + "启动");
					c.await();
					t1.test1();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println(Thread.currentThread().getName() + "启动");
					c.await();
					t1.test2();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
		c.countDown();
	}
	/*
	 * 结果 同一个对象，当其中一个线程没有释放锁时，另一个会一直等待。 Thread-1启动 Thread-1--- test2 Doing
	 * Thread-0启动 Thread-1---test1 Doing Thread-1--- test2 Doing
	 * Thread-1---test1 Doing Thread-1--- test2 Doing
	 */
}

渺小的码字员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
5.juc学习进程（五、synchronized、volatile区别）

在并发编程中分析线程安全的问题时往往需要切入点，那就是两大核心：JMM抽象内存模型以及 happens-before规则三条性质：原子性，有序性和可见性。关于synchronized和volatile已经讨论过了，就想着将并发编程中这两大神器在原子性，有序性和可见性上做一个比较，当然这也是面试中的高频考点，值得注意。synchronized: 具有原子性，有序性和可见性；volatile：具有有序性和可见性。
复制链接

扫一扫