volatile和synchronized关键字

synchronized

java课上讲到过synchronized

首先看看用synchronized和没用synchronized的区别

import lombok.Getter;
/**
 * @author yintianhao
 * @createTime 20190123 16:28
 * @description synchronized
 */
public class SYN {
    @Getter
    private int count;
    private Object lock;
    public SYN(){
        count = 0;
        lock = new Object();
    }
    public void noSyn(){
        for (int i = 0;i < 100;i++){
            count++;
        }
    }
    public void Syn(){
        synchronized (lock){
            for (int i = 0;i < 100;i++){
                count++;
            }
        }
    }
}

要进行的操作是对count进行自增操作,执行一次里面的Syn和noSyn函数都是对count这个变量进行加一百次的操作

不同的就是,Syn函数用了synchronized

然后开启十个线程来执行这两个函数,之后打印出count的值,我们期望的是count等于1000

List<Thread> threads = new ArrayList<>();
        SYN syn = new SYN();
        for (int i = 0;i < 10;i++){
            threads.add(new Thread(()->syn.noSyn(),"thread-"+i));
        }
        for (Thread o:threads)
            o.start();
        for (Thread o:threads)
            o.join();
        System.out.println(syn.getCount());

再看运行结果

可是结果却不是1000

然后再把运行的函数改成Syn(),再次看结果

1000符合预期,为了避免偶然,重复运行几次结果仍是1000

那么为什么这里结果不同的呢,原因就是牵涉到另外一个概念,锁,在这个例子中,SYN类中的lock对象就可以看做一把锁

只有拿到锁,才能执行synchronized代码块中的代码块,所以当一个线程在执行synchronized里面的代码并且还没把锁交出来(释放)时,其他线程无法获取

到锁,故无法执行其中的代码,在没有使用synchronized的函数中,因为没有锁机制,有可能for循环还没结束的时候就有新的进程进来,即没有加到100就进来

故count最后不会到1000,而且也不是一个固定的数字

synchronized的实现原理

synchronized有三种用法:

第一种是对于同步方法,即修饰某个函数,这个时候锁对象是当前类的实例化对象

第二种是对于同步静态方法,这个时候锁是当前类的Class对象

第三种就是我上面的用法,对于同步代码块,锁是括号里的对象

前面说一个进程会获得锁,那么这个锁是存在在什么地方呢

首先需要了解java对象头,对象头分为两种

普通对象的对象头占两个字宽

数组对象的对象头占三个字宽,相比于普通对象的对象头多了一个字宽来存储数组长度

java对象头中的Markword字段中存储对象的HashCode,分代年龄和锁标记位,在运行期间,MarkWord存储的数据会随着锁标志位

的变化为变化,MarkWord的结构是这个样子的

这个锁的标志位就是锁的类型了,也就是之前所说的"锁"

Volatile

java对volatile的定义是:Java编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致地更新,线程应该确保通过排他锁单独获得这个变量,

如果一个字段被申明为volatile,线程内存模型确保所有线程能够看到的这个变量的值是一致的

那么volatile是怎么保证可见性的呢

我们知道处理器为了保证处理的速度,是不和系统内存直接通信的,因为内存的速度远远慢yu每个处理器先是将系统内存中的数据读入到CPU内部缓存中

再进行操作,但是操作完成之后是不知道什么时候缓存中的数据会写到内存中的,那么其他处理器读取这个变量的时候就有可能读取到旧的数据,volatile是

这样子做的,一旦被volatile修饰的变量发生读写操作,就会发生两个动作:

1,将当前处理器缓存行的数据写到系统内存中(这是Lock前缀指令会引起的)

2,然后这个操作使得其他CPU缓存了该内存地址的数据无效

然后我们知道的是,每个处理器中的缓存是一致的,那么这个时候就需要缓存一致性协议,每个处理器嗅探总线上传播的数据来检测自己缓存中的值是否过期,

当发现自己的缓存行对应的内存地址被修改,就会将自己缓存行设置为无效,当需要修改的时候,重新从系统内存读取到缓存行,这样就实现了可见性

原文地址:https://www.cnblogs.com/Yintianhao/p/10311765.html

时间: 2024-10-18 02:37:44

volatile和synchronized关键字的相关文章

从JAVA看C#中volatile和synchronized关键字的作用

最近一直在想C#中 volatile关键字到底是用来干什么的?查了很多.NET的文章都是说用volatile修饰的变量可以让多线程同时修改,这是什么鬼... 然后查到了下面这篇JAVA中关于volatile和synchronized关键字的概述,总算对volatile和synchronized关键字有了个大概的了解,而C#中应该类似,注意C#中没有synchronized关键字,但是有MethodImplAttribute 类 和 SynchronizationAttribute 类与JAVA中

volatile与synchronized关键字

volatile关键字相信了解Java多线程的读者都很清楚它的作用.volatile关键字用于声明简单类型变量,如int.float.boolean等数据类型.如果这些简单数据类型声明为volatile,对它们的操作就会变成原子级别的.但这有一定的限制.例如,下面的例子中的n就不是原子级别的: public class JoinThread extends Thread { public static volatile int n = 0; public void run() { for (in

volatile关键字和synchronized关键字

volatile关键字: 可以用来修饰字段(成员变量),就是告知程序任何对该变量的访问均需要从共享内存中获取,而对它的改变必须同步刷新回共享内存,它能保证所有线程对变量访问的可见性. synchronized关键字: 可以修饰方法或以同步块的形式来进行使用,它主要确保多个线程在同一时刻,只能有一个线程处于方法或者同步块中,它保证了对变量访问的可见性和排他性. package com.baidu.nuomi.concurrent; /** * Created by sonofelice on 16

并发编程之ThreadLocal、Volatile、synchronized、Atomic关键字扫盲

前言 对于ThreadLocal.Volatile.synchronized.Atomic这四个关键字,我想一提及到大家肯定都想到的是解决在多线程并发环境下资源的共享问题,但是要细说每一个的特点.区别.应用场景.内部实现等,却可能模糊不清,说不出个所以然来,所以,本文就对这几个关键字做一些作用.特点.实现上的讲解. 1.Atomic 作用 对于原子操作类,Java的concurrent并发包中主要为我们提供了这么几个常用的:AtomicInteger.AtomicLong.AtomicBoole

java学习:JMM(java memory model)、volatile、synchronized、AtomicXXX理解

一.JMM(java memory model)内存模型 从网上淘来二张图: 上面这张图说的是,在多核CPU的系统中,每个核CPU自带高速缓存,然后计算机主板上也有一块内存-称为主内(即:内存条).工作时,CPU的高速缓存中的数据通过一系列手段来保证与主内的数据一致(CacheCoherence),更直白点,高速缓存要从主内中load数据,处理完以后,还要save回主存. 上图说的是,java中的各种变量(variable)保存在主存中,然后每个线程自己也有自己的工作内存区(working me

volatile 与 synchronized 区别

在Java中,为了保证多线程读写数据时保证数据的一致性,可以采用两种方式: 同步 如用synchronized关键字,或者使用锁对象. volatile 使用volatile关键字用一句话概括volatile,它能够使变量在值发生改变时能尽快地让其他线程知道. volatile详解 首先我们要先意识到有这样的现象,编译器为了加快程序运行的速度,对一些变量的写操作会先在寄存器或者是CPU缓存上进行,最后才写入内存.而在这个过程,变量的新值对其他线程是不可见的.而volatile的作用就是使它修饰的

Effective Item - 合理使用synchronized关键字

记得最初使用synchronized关键字时是为了singleton. 仅仅是判断field是不是null,如果为null则指向新的实例. 但这种check-and-action的方式会有同步的问题,也就是说"同时"有两个线程通过了check. 通过这种体验得出了最基本的结论:synchronized可以保证在同一时刻只有一个线程可以执行某个代码块. 很多人把同步的概念仅仅理解为互斥关系(mutual exclusion). 比如,当一个对象被一个线程修改的时候可以阻止其他线程观察到该

volatile与synchronized的区别

1.锁提供了两种主要特性:互斥(mutual exclusion) 和可见性(visibility). 互斥即一次只允许一个线程持有某个特定的锁,因此可使用该特性实现对共享数据的协调访问协议,这样,一次就只有一个线程能够使用该共享数据. 可见性要更加复杂一些,它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证,线程看到的共享         变量可能是修改前的值或不一致的值,这将引发许多严重问题.(竞态条件) 2.在Java中

JAVA多线程之volatile 与 synchronized 的比较

一,volatile关键字的可见性 要想理解volatile关键字,得先了解下JAVA的内存模型,Java内存模型的抽象示意图如下: 从图中可以看出: ①每个线程都有一个自己的本地内存空间--线程栈空间???线程执行时,先把变量从主内存读取到线程自己的本地内存空间,然后再对该变量进行操作 ②对该变量操作完后,在某个时间再把变量刷新回主内存 关于JAVA内存模型,更详细的可参考: 深入理解Java内存模型(一)——基础 因此,就存在内存可见性问题,看一个示例程序:(摘自书上) 1 public c