java中volatile的作用概述
java中volatile是一种弱同步。那么将一个变量声明为volatile，与非volatile有什么不同呢？
1、（jdk1.5之前没有这一条）提醒编译器和运行时环境，在volatile变量上的操作不能与其它操作重排序。譬如在new一个对象时,先分配空间，调用&clinit&方法（即static块和类变量初始化，按声明顺序排列），此时已经得到对象地址了，再在其上调用&init&方法（先对象属性初始化，再调用构造方法体）。那么在Person p = new Person(&abc&)的时候，有可能构造方法体还没有构造，p就已经被赋值了。在单线程环境下，这不会带来问题。但在多线程下，就有问题了，典型的问题就是单例模式的双重锁定检查问题，jdk1.4的时候，这种模式的单例是有问题的。
2、volatile变量不会缓存到CPU寄存器或cache中，确保变量的可见性。所以读取一个volatile变量的值总是返回其最近写入的值。
3、对于64位的long和double的操作是原子的（这里的原子指的是读取和赋值不会被分为两次进行，如a=1L，不会先写高32位，再写低32位，或相反的操作，确保其它线程不会获取到一个只写了一半的错误值）。jvm规范鼓励jvm实现者将long和double的操作作为原子性的，但这并不是强制性的，也就是说一个非volatile的long或double类型的变量，其上的操作可能是原子性的也可能是分成两个32位来进行的，并没有任何保证；一旦声明为volatile，即可保证long和double上的操作是原子性的。
标签(Tag):
------分隔线----------------------------
------分隔线----------------------------java中volatile关键字如何解析
&&来源：华宇盈通
在java的学习中，我们会遇到很多的知识点，因此想要深入的去了解更多的java功能，就要去了解更多的知识点来丰富自己的了解，今天我们主要来说一说Java中volatile关键字如何解析。
public class ThreadSee {&
//t1线程会根据flag的值做对应的操作，主线程会更改t1的值&
&public static void main(String[] args) throws InterruptedException {&
& & ThReadTest th= new ThReadTest();&
& & Thread t1 = new Thread(th);&
& & t1.start();&
& & Thread.sleep(1000);&
& & th.changeFlag();&
& & Thread.sleep(2000);&
& & System.out.println(th.getFlag());&
class ThReadTest implements Runnable{&
& //线程访问变量时会把其load到对应的线程栈中，每次操作时都要获取内存中最新的数据&
& private volat&
& @Override
& public void run() {&
& & int i=0;&
& & while(!stopflag){&
& & & i++;&
& & & System.out.println("=="+Thread.currentThread().getName());&
& & System.out.println("Thread finish:"+i);&
& public void changeFlag(){&
& & this.stopflag=&
& & System.out.println(Thread.currentThread().getName()+"***********");&
& public boolean getFlag(){&
上述代码如果去掉volatile,但是以上的操作会一直死循环执行下去，但是volatile不能保证线程安全的同步，再来看看一下的代码：
public class ThreadSave implements Runnable{&
& static ThreadSave sync = new ThreadSave();&
& static volatile int j=0;&
& //Lock lock =new ReentrantLock();&
& public void inscane(){&
& & // lock.lock();&
& & for(int i=0;i&;i++){&
& & & j++;&
& &// &lock.unlock();&
& @Override
& public void run() {&
& & inscane();&
& public static void main(String[] args) throws InterruptedException {&
& & Thread t1 = new Thread(sync);&
& & Thread t2 = new Thread(sync);&
& & t1.start();&
& & t2.start();&
& & t1.join();&
& & t2.join();&
& & System.out.println(j);&
volatile只会保证线程去做一个检查当前线程栈的变量值和主内存中数据值是否一样的这么一个动作，只此而已。而lock或者是synchronized 会保证某一时刻只有单个线程进入该方法，从而确保其线程安全性。所以在如果多个线程去修改一个volatile变量那么没有实际的逻辑意义。如果一个线程去修改其他的线程依赖修改的变量值，此时是有作用的。
以上就是java中volatile关键字解析的方法，如果你对这方面的内容比较感兴趣，希望以上内容对你有所帮助。
地址：北京市海淀区中关村软件园西三旗上奥世纪中心A座1903
电话：010-
传真：010-
邮编：100096关于synchronized与volatile的一点认识 - 推酷
关于synchronized与volatile的一点认识
贪婪是一种原罪，不要再追求性能的路上离正确越来越远。
java内存模型
提到同步、锁，就必须提到java的内存模型，为了提高程序的执行效率，java也吸收了传统应用程序的多级缓存体系。
在共享内存的多处理器体系架构中，每个处理器都拥有自己的缓存，并且定期地与主内存进行协调。在不同的处理器架构中提供了不同级别的缓存一致性（Cache Coherence）,其中一部分只提供最小的保证，即允许不同的处理器在任意时刻从同一个存储位置上看到不同的值。操作系统、编译器以及运行时（有时甚至包括应用程序）需要弥合这种在硬件能力与线程安全之间的差异。
要想确保每个处理器都能在任意时刻知道其他处理器正在进行的工作，将需要非常大的开销。在大多数时间里，这种信息是不必要的。因此处理器会适当放宽存储一致性保证，以换取性能的提升。在架构定义的内存模型中将告诉应用程序可以从内存系统中获得怎样的保证，此外还定义了一些特殊的指令（称为内存栅栏），当需要共享数据时，这些指令就能实现额外的存储协调保证。为了使java开发人员无须关心不同架构内存模型之间的差异，Java还提供了自己的内存模型，并且JVM通过在适当的位置上插入内存栅栏来屏蔽在JVM与底层之平台内存模型之间的差异。
经过上面的讲解和上图，我们知道线程在运行时候有一块内存专用区域，Java程序会将变量同步到线程所在的内存。这时候会操作工作内存中的变量，而线程中的变量何时同步回到内存是不可预期的。但是java内存模型规定，通过关键词”synchronized“、”volatile“可以让java保证某些约束。
“volatile” - 保证读写的都是主内存变量。“synchronized” - 保证在块开始时，都同步主内存值到工作内存，而快结束时，将工作内存同步会主内存。
public class PossibleReordering {
static int x = 0,y=0;
static int a=0,b=0;
public static void main(String[] args) throws InterruptedException {
Thread one = new Thread(new Runnable() {
public void run() {
Thread two = new Thread(new Runnable() {
public void run() {
one.start();two.start();
one.join();two.join();
System.out.println(&x:& + x+&,y:&+y);
重排序。如上图，执行结果，一般人可能认为是1，1；真正的执行结果可能每次都不一样。拜JMM重排序所赐，JMM使得不同线程的操作顺序是不同的，从而导致在缺乏同步的情况下，要推断操作的执行结果将变得更加复杂。各种使操作延迟或看似乱序执行的不同原因，都可以归为重排序。内存级的重排序会使程序的行为变得不可预测。如果没有同步，要推断出程序的执行顺序是非常困难的，而要确保在程序中正确的使用同步却是非常容易的。同步将限制编译器和硬件运行时对内存操作重排序的方式。
锁synchronized
锁实现了对临界资源的互斥访问，被synchronized修饰的代码只有一条线程可以通过，是严格的排它锁、互斥锁。没有获得对应锁对象监视器（monitor）的线程会进入等待队列，任何线程必须获得monitor的所有权才可以进入同步块，退出同步快或者遇到异常都要释放所有权，JVM规范通过两个内存屏障（memory barrier）命令来实现排它逻辑。内存屏障可以理解成顺序执行的一组CPU指令，完全无视指令重排序。
public class TestStatic {
public syncronized static void write(boolean flag) {
public synchronized static void read() {
线程1访问TestStatic.write()方法时，线程2能访问TestStatic.read()方法吗
线程1访问new TestStatic().write()方法时，线程2能访问new TestStatic().read()方法吗
线程1访问TestStatic.write()方法时，线程2能访问new TestStatic().read()方法吗
public class Test {
public syncronized void write(boolean flag) {
public synchronized void read() {
Test test = new Test();线程1访问test.write() 方法，线程2能否访问test.read()方法
Test a = new Test(); Test b = new Test();线程1访问a.write()访问，线程2能否访问b.read()方法
答案，java中每个对象都可以作为一个锁，而对象就决定了锁的粒度大小。
对于实例同步方法，锁是当前对象。
对于静态方法，锁是TestSTatic.class对象
对于同步代码块，锁是Synchronized括号里面配置的对象
TestStatic类，1问，作用范围全体class对象，线程1拿到，线程2就不能拿到
2问，3问同上
Test类，1问，不能，锁都是实例对象test，线程1拿到锁之后，线程2无法访问
2问，可以，线程1锁是实例a，线程2是实例b。
如果你不敢确定该用什么锁，就用这个吧，在保证正确的前提下，后续在提高开发效率。
public class ServerStatus {
public final Set&String&
public final Set&String&
public synchronized void addUser(String u ) {
users.add(u);
public synchronized void addQuery(String q ) {
quers.add(q);
public synchronized void removeUser(String u) {
users.remove(u);
public synchronized void removeQuery(String q) {
quers.remove(q);
如果在整个应用程序只有一个锁，而不是为每个对象分配一个独立的锁，那么所有同步代码块的执行就会变成串行化执行。由于很多线程都会竞争同一个全局锁，因此两个线程同时请求这个锁的概率将会剧增，从而导致更严重的竞争。所以如果将这些锁请求分到更多的锁上，就能有效降低锁竞争程度。由于等待而被阻塞的线程将更少，从而可伸缩性将提高。
上文中users、quers是两个相互独立的变量，可以将此分解为两个独立的锁，每个锁只保护一个变量，降低每个锁被请求的频率。
public class ServerStatus {
public final Set&String&
public final Set&String&
public void addUser(String u ) {
synchronized(users) {
users.add(u);
public void addQuery(String q ) {
synchronized(quers) {
quers.add(q);
public void removeUser(String u) {
synchronized(users) {
users.remove(u);
public void removeQuery(String q) {
synchronized(quers) {
quers.remove(q);
在某些情况下，可以将锁分解技术进一步扩展为对一组独立对象上的锁进行分解，这种情况称为锁分段。例如ConcurrencyHashMap是有一个包含16个锁的数组实现，每个锁保护所有散列桶的1/16，其中第N个散列桶由第（N mod 16）个锁来保护。假设所有关键字都时间均与分布，那么相当于把锁的请求减少到原来的1/16，可以支持多达16个的并发写入。
锁分段的劣势在于：与采用单个锁来实现独占访问相比，要获取多个锁来实现独占访问将更加困难并且开销更高，比如计算size、重hash。
zookeeper，判断临时节点是否存在，存在就说明已经有人争抢到锁；不存在就创建节点，表明拥有该锁。
记下，以后详细研究
volatile是比synchronized更轻量级的同步原语，volatile可以修饰实例变量、静态变量、以及数组变量（网上大牛说，维护的是引用，但是里面的对象。。。嘿嘿嘿）。被volatile修饰的变量，JVM规范规定，一个线程在修改完，另外的线程能读取最新的值。
但仅仅保证可见性，不保证原子性，所以volatile通常用来修饰boolean类型或者状态比较少的数据类型，而且不能用来更新依赖变量之前值的操作（例volatile++）。
volatile内部仅仅是对变量的操作多了一条cpu指令（lock#指令），它会强制写数据到缓存，如果缓存数据同时也在主存，会强制写数据更新到主存，并且使所有持有该主存数据地址的缓存统统失效，触发其他持有缓存数据的线程从主存获取最新数据，从而实现同步。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致