精华内容
下载资源
问答
  • Java synchronized&volatile

    2018-03-12 08:20:34
    Java中每一个对象都可以作为锁,这是synchronized实现同步的基础: 普通同步方法,锁是当前实例对象; 静态同步方法,锁是当前类的class对象; 同步方法块,锁是括号里面的对象。 1. synchronized对象锁 ...

    synchronized可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同时它还可以保证共享变量的内存可见性

    Java中每一个对象都可以作为锁,这是synchronized实现同步的基础:

    1. 普通同步方法,锁是当前实例对象;
    2. 静态同步方法,锁是当前类的class对象;
    3. 同步方法块,锁是括号里面的对象。

    1. synchronized对象锁

    synchronized可以修饰实例方法,主要有两种:

    public class MyObject {
    
         synchronized public void methodA() {
             //do something....
         }
    public class MyObject {
    
        public void methodA() {
            synchronized(this){
                //do something....
            }
        }

    synchronized 关键字锁住的是当前对象。这也是称为对象锁的原因。

    2. 线程间通讯

    传统的线程通信可以借助Object类提供的wait() notify() notifyAll()三个方法实现:

    1. wait():导致当前线程等待,直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒线程,调用wait()方法的当前线程会释放对该同步监视器的锁定;

    2. notify():唤醒在此同步监视器上等待的单个线程,如果所有线程都在此同步监视器上等待,则会选择唤醒其中一个线程(选择是任意性的)。只有当前线程放弃对该同步监视器的锁定后(使用wait()方法),才可以执行被唤醒的线程;

    3. notifyAll():唤醒在此同步监视器上等待的所有线程,只有当前线程放弃对该同步监视器的锁定后(使用wait()方法),才可以执行被唤醒的线程;

    • 对于使用synchronized修饰的同步方法,因为该类的默认实例(this)就是同步监视器,所以可以在同步方法中直接调用这三个方法;
    • 对于使用synchronized修饰的同步代码块,同步监视器是synchronized后括号里的对象,所以必须使用该对象调用者三个方法。

    3. volatile

    • volatile保证多线程共享变量可见性。
    • 禁止指令重排序
    • 不保证原子性

    volatile 定义的变量,特殊性在于:

    一个线程对 volatile 变量的写一定对之后对这个变量的读的线程可见。

    即:

    一个线程对 volatile 变量的读一定能看见在它之前最后一个线程对这个变量的写。

    4. volatile 和 synchronized比较

    1. 当线程对 volatile变量写时,java 会把值刷新到共享内存中;而对于synchronized,指的是当线程释放锁的时候,会将共享变量的值刷新到主内存中。

    2. 线程读取volatile变量时,会将本地内存中的共享变量置为无效;对于synchronized来说,当线程获取锁时,会将当前线程本地内存中的共享变量置为无效。

    3. synchronized 扩大了可见影响的范围,扩大到了synchronized作用的代码块。

    展开全文
  • 主要为大家详细介绍了Java关键字volatilesynchronized的作用和区别,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了javavolatilesynchronized的区别与联系的相关资料,希望通过本文能帮助到大家,让大家理解这部分内容,需要的朋友可以参考下
  • javavolatilesynchronized关键字都是伴随着多线程经常使用的关键字,很多然搞不清楚二者的区别,这篇文章记录下来笔者的一点认识,若有不正确的地方欢迎大家在评论区指出。 区别 volatile本质是在告诉jvm...

    概述

    java中volatile和synchronized关键字都是伴随着多线程经常使用的关键字,很多然搞不清楚二者的区别,这篇文章记录下来笔者的一点认识,若有不正确的地方欢迎大家在评论区指出。

    区别

    • volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。
    • volatile仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别
    • volatile仅能实现变量的修改可见性,不能保证原子性;而synchronized则可以保证变量的修改可见性和原子性
    • volatile不会造成线程的阻塞;synchronized可能会造成线程的阻塞。
    • volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化

    加粗字体部分的原因如下:
    线程A修改了变量还没结束时,另外的线程B可以看到已修改的值,而且可以修改这个变量,而不用等待A释放锁,因为Volatile 变量没上锁。

    举例

    用在多线程,同步变量。 线程为了提高效率,将某成员变量(如A)拷贝了一份(如B),线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm, 它所修饰的变量不保留拷贝,直接访问主内存中的(也就是上面说的A)

    总结

    synchronized关键字很好理解,就是保证所修饰的变量、方法、和类同时只能被一个xx调用(这里没想好修饰词),而volatile是为了保证变量可以同时被多个线程调用,而且没有上锁,即上面提到的线程A修改了变量还没结束时,另外的线程B可以看到已修改的值,这种机制有利有弊,希望大家使用的时候一定要慎重。

    展开全文
  • /** * @Package * @Description * @author chenj * @date 2015-9-14 下午11:09:40 * @version V1.0 ...import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; impo

    java中可以使用 synchronized volatile Atomic  LOCK进行多线程编程来实现线程安全。现对这几种方式进行演示与总结。


    其中:


    1. 单纯使用volatile是没有办法保证线程安全的

    2. 使用synchronized和 lock要注意使用方法,要在主进程中创建lock对象的实例或定义synchronized方法

    3. 使用Atomic  原子类也是可以保证线程安全的。


    /**   
    
     * @Package  
     * @Description 
     * @author chenj
     * @date 2015-9-14 下午11:09:40 
     * @version V1.0   
     */
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 
     * @author chenj| 2015-01-01
     *
     */
    public class TestMultiThread{
    	Object _object = new Object();
    
    	static int i=0;
    	
    	static Integer si = 0;
    	
    	static volatile Integer vi = 0;
    	
    	static AtomicInteger autoInteger = new AtomicInteger();
    	
    	static int synClassInt = 0;
    	
    	static int lockInt = 0;
    	
    	static int staticClassInt = 0;
    	
    	static Lock lock = new ReentrantLock();
    	
    	static Object _obj = new Object();
    
    	public void testVolatileInteger(Thread _thread1,Thread _thread2) throws Exception{
            ExecutorService pool = Executors.newCachedThreadPool();
            //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
            Thread t1 = _thread1;
            Thread t2 = _thread2;
            //将线程放入池中进行执行
            pool.execute(t1);
            pool.execute(t2);
            //关闭线程池
            pool.shutdown();
            while(true){  
                if(pool.isTerminated()){  
                	if(staticClassInt!=0){
    	                System.out.println("所有的子线程都结束了!"); 
    					System.out.println("i>>>>>"+i);
    					System.out.println("vi>>>>>"+vi);
    					System.out.println("si>>>>>"+si);	
    					System.out.println("autoInteger>>>>>"+autoInteger);	
    					System.out.println("synClassInt>>>>>"+synClassInt);	
    					System.out.println("lockInt>>>>>"+lockInt);	
    					System.out.println("staticClassInt>>>>>"+staticClassInt);	
                	}
                    break;  
                }   
            }  
    	}
    	
    	public synchronized static void testSychronizedMethod() {
    		i++;
    	}
    	
    	static class testSychronizedMethodClass extends Thread{
    		@Override
    	    public void run() {
    	    	for(int k=0;k<200000;k++){
    	    		testValue();
    	    	}
    	    }
    	    public static void testValue() {
    
    	    	staticClassInt++ ;
    	    }
    	}   
    
    	public static void main(String[] args) throws Exception{
    		TestMultiThread testMultiThread = new TestMultiThread();
    				
    		testMultiThread.testVolatileInteger(new ThreadSychronizedMethead(),new ThreadSychronizedMethead());
    		Thread.sleep(100);
    		
    		testMultiThread.testVolatileInteger(new ThreadStaticInteger(),new ThreadStaticInteger());
    		Thread.sleep(100);
    		
    		testMultiThread.testVolatileInteger(new ThreadStaticVolatileInteger(),new ThreadStaticVolatileInteger());
    		Thread.sleep(100);
    
    		testMultiThread.testVolatileInteger(new ThreadAtomicInteger(),new ThreadAtomicInteger());
    		Thread.sleep(100);
    		
    		testMultiThread.testVolatileInteger(new ThreadSychronizedObjMethead(),new ThreadSychronizedObjMethead());
    		Thread.sleep(100);
    		
    		testMultiThread.testVolatileInteger(new ThreadLock(),new ThreadLock());
    		Thread.sleep(100);
    		
    		testMultiThread.testVolatileInteger(new TestMultiThread.testSychronizedMethodClass(),new TestMultiThread.testSychronizedMethodClass());
    		Thread.sleep(100);
    	}
    }
    
    class ThreadStaticVolatileInteger extends Thread {
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		TestMultiThread.vi++;
        	}
        }
    }
    
    class ThreadAtomicInteger extends Thread {
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		TestMultiThread.autoInteger.incrementAndGet();
        	}
        }
    }
    
    class ThreadStaticInteger extends Thread {
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		TestMultiThread.si++;
        	}
        }
    }
    
    class ThreadSychronizedMethead extends Thread {
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		TestMultiThread.testSychronizedMethod();
        	}
        }
        
        public synchronized void test() {
    		TestMultiThread.i++;
    	}
    }
    
    class ThreadSychronizedObjMethead extends Thread {
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		synchronized(TestMultiThread._obj){
        			TestMultiThread.synClassInt++;
        		}
        	}
        }
    }
    
    class ThreadLock extends Thread {
    	
        @Override
        public void run() {
        	for(int k=0;k<200000;k++){
        		lockObj();
        	}
        }
        
        public void lockObj(){
        	TestMultiThread.lock.lock();
    		try{
    			TestMultiThread.lockInt ++;
    		}finally{
    			TestMultiThread.lock.unlock();
    		}
    	}
    }

    程序运行结果:

    所有的子线程都结束了!
    i>>>>>400000
    vi>>>>>257432
    si>>>>>222170
    autoInteger>>>>>400000
    synClassInt>>>>>400000
    lockInt>>>>>400000
    staticClassInt>>>>>266997



    展开全文
  • 在多线程和并发编程中,免不了要使用到VolatileSynchronized关键字,但是之前对这2个关键字的理解总是很模糊,在看完了《Java多线程编程核心技术》这本书后对多线程有了比较清晰地认识。最近在看《Java并发编程...

    在多线程和并发编程中,免不了要使用到Volatile和Synchronized关键字,但是之前对这2个关键字的理解总是很模糊,在看完了《Java多线程编程核心技术》这本书后对多线程有了比较清晰地认识。最近在看《Java并发编程实战》这本书,书中对Java的Volatile和Synchronized有很详细的介绍和剖析,让我进一步有了新的认识,在博客做个总结,记录自己的学习心得。

    、java的加锁机制通常有2种方式:用Synchronized实现同步互斥和用Lock实现加锁。
    对于一个可变的变量a,在单线程环境中执行不会遇到线程安全问题,但是当多个线程同时访问这个共享变量时,有可能一个线程读到了a的值已经被另一个线程修改,会导致线程不安全。
    为了解决这个问题,可以使用加锁机制,保住每次只有一个线程能对共享变量访问,其他线程必须排队等候。
    Volatile关键字:可见性
    Java用Volatile提供了一种稍弱的同步机制,用来确保将变量的更新操作通知到其他线程。Volatile是比Synchronized更轻量级的同步机制。
    重点
    加锁机制既可以确保可见性,又可以确保原子性;
    而Volitile变量只能确保可见性。

    展开全文
  • java中的多线程并发问题是一个让人头疼的问题,因为当多个线程访问同一个资源时,由于一段操作非原子性,就会导致可能出现操作到一半的时候,cpu时间片被切换到其它线程里面去,最终再切换回来的时候... synchronized
  • javavolatilesynchronized和lock解析

    千次阅读 多人点赞 2017-03-07 21:10:34
    1、概述在研究并发程序时,我们需要了解java中关键字volatilesynchronized关键字的使用以及lock类的用法。首先,了解下java的内存模型:(1)每个线程都有自己的本地内存空间(java栈中的帧)。线程执行时,先把...
  • 提到synchronizedvolatile这两个有关线程的关键字,那我们先来说一下Java的内存模型(JMM). Java内存模型(java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则,以及在JVM中将变量存储到内存和从...
  • JAVAvolatilesynchronized的区别

    万次阅读 2018-08-07 19:45:45
    volatilesynchronized的区别 共性:volatilesynchronized都用于保证多线程中数据的安全 区别: (1)volatile修饰的变量,jvm每次都从主存(主内存)中读取,而不会从寄存器(工作内存)中读取。 而...
  • Javasynchronizedvolatile关键字作用

    千次阅读 2019-01-18 18:56:16
    synchronized关键字 synchronized 即锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。 synchronized 的作用范围:可以...volatile关键字 一旦一个共享变量(类的成员变量、类的静态成员变量)被 vo...
  • 多线程访问volatile不会发生阻塞,而synchronized会出现阻塞。 volatile解决的是变量在多个线程之间的可见性,但不能保证原子性;而synchronized保证原子性,也可间接保证可见性,因为它会将私有内存和公共内存中...
  • volatile是一个轻量级的synchronized,它不会引起线程上下文的切换和调度。 官方定义:Java编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致地更新,线程应该确保通过排他锁单独获得这个变量。 ...
  • volatilesynchronized都可以实现Java的同步机制,那么volatilesynchronized的区别是什么,比如作用范围等,并解释其实现原理
  • 恐怕比较一下volatilesynchronized的不同是最容易解释清楚的。volatile是变 量修饰符,而synchronized则作用于一段代码或方法;看如下三句get代码: int i1; int geti1() {return i1;} volatile int i2; int...
  • Java线程控制中常用的两个关键字:synchronizedvolatile volatile关键字特性: 内存可见性(Memory Visibility),所有线程都能看到共享内存的最新状态; 有序性; 不具备原子性(最致命缺点)。 对于volatile修饰...
  • 2. volatile 本质就是告诉JVM,当前变量在寄存器中的值不确定,需要从主存中读取。synchronized 锁定了当前变量,只有当前线程可以访问该变量。 3. 区别: volatile 修饰变量;synchronized 修饰方法和代码块...
  • volatile
  • JavaVolatileSynchronized的区别 JMM Java Memory Model. 并发过程中如何处理可见性、原子性、有序性的问题 Runnable、Thread 并发编程中的两个关键问题 a.线程之间如何通信 wait() notify() notifyall() a) ...
  • 主要介绍了Java线程之线程同步synchronizedvolatile详解,具有一定参考价值,需要的朋友可以了解下。
  • Java多线程编程中,synchronized是非常常用的关键字,而volatile关键字比较罕见。 从Java 1.5开始,volatile关键字被赋予了新的特性,使其能够实现更轻量级的并发访问控制。 首先从用处
  • java中,volatile,synchronized都是用于多线程中用于数据同步的。 volatile关键字一般修饰成员变量。被volatile修饰的成员变量被多个线程访问时,所有的线程都从共享内存中拷贝一个副本在自己的线程中...
  • java-synchronizedvolatile

    2016-10-12 10:28:18
    synchronized 即能保证可见性,又能保证原子性。 volatile只能保证可见性,不能保证原子性。 导致共享变量在线程间不可见的原因 1.线程的交叉执行 2.重排序结合线程交叉执行 3.共享变量更新后的值没有及时更新...
  • 文章目录synchronizedvolatile1 Java内存模型JMM2 伪共享3 指令重排4 synchronized5 volatile6 synchronized和Lock7 synchronizedvolatile synchronizedvolatile 1 Java内存模型JMM 所有共享变量都存储在主存...
  • synchronizedvolatile
  • 文章目录一.synchronized1.synchronized...引出问题2. `volatile`使用方法3.volatile原理4.volatile三大特性三、volatilesynchronized的区别1.区别2.解决原子性问题--原子型数据类型3.让对象类型数据具有原子型 一...
  • 在开发当中使用多线程的,经常会用到synchronized和volatitle。接下来就讲讲他们的使用场景。 synchronized java关键字,方法用到这个关键字则对这个方法进行加锁。...volatile java关键字,用来声明变量。 1....
  • java多线程的内存模型 : 每个线程在运行期间都有自己独立的内存区域,用于存储变量等数据,多线程环境中,有一个内存共享区域,我们也称之为主内存,每个线程都可以访问这块区域,这块区域的变量叫共享变量。线程...
  • synchronizedvolatile的使用方法以及区别 先看看下面的例子: public class ThreadTest { public static void main(String[] args) { final Counter counter = new Counter(); for (int i = 0; i &lt...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 117,988
精华内容 47,195
关键字:

javasynchronizedvolatile

java 订阅