【Java基础】Volatile & synchronized

最新推荐文章于 2025-07-06 20:05:18 发布

原创最新推荐文章于 2025-07-06 20:05:18 发布 · 314 阅读

CC 4.0 BY-SA版权

本文深入探讨了Java中volatile和synchronized两种并发控制机制的特点及使用场景。解释了volatile如何确保变量的一致性，并强调其轻量级特性。同时，详细说明了synchronized的工作原理，包括如何正确地使用它来实现线程间的同步。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Volatile：

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。
要解决这个问题，就需要把变量声明为volatile，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下，各任务间共享的变量都应该加volatile修饰符。
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才将私有拷贝与共享内存中的原始值进行比较。这样当多个线程同时与某个对象交互时，就必须注意到要让线程及时的得到共享成员变量的变化。而volatile关键字就是提示JVM：对于这个成员变量，不能保存它的私有拷贝，而应直接与共享成员变量交互。
volatile是一种稍弱的同步机制，在访问volatile变量时不会执行加锁操作，也就不会执行线程阻塞，因此volatilei变量是一种比synchronized关键字更轻量级的同步机制。
使用建议：在两个或者更多的线程需要访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，没必要使用volatile。
由于使用volatile屏蔽掉了JVM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。
Volatile一般情况下不能代替sychronized，因为volatile不能保证操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。如果配合Java 5增加的atomic wrapper classes，对它们的increase之类的操作就不需要sychronized。
总结一下，volatile可以修饰变量，用于多线程的访问，但是在多核的情况下，多线程并发还是存在问题。所以最好使用sychronized。

Synchronized

我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，他取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）和之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

1、把synchronized当作函数修饰符时，示例代码如下：

   public synchronized void method(){}

他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了synchronized关键字的方法。
上边的示例代码等同于如下代码：

public void method(){      
	synchronized (this){      
       //…..      
	}      
}

2、同步块，示例代码如下：

public void method(SomeObject so) {      
	synchronized(so){      
       //…..      
	}      
}

这时，锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（他得是个对象）来充当锁：

class Foo implements Runnable{      
    private byte[] lock = new byte[0];  // 特别的instance变量      
    Public void method(){      
       synchronized(lock) { //… }      
	}
}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

3．将synchronized作用于static 函数，示例代码如下：

Class Foo{ 
	static Object o = new Object;     
	public synchronized static void method1(){      
		//….      
	}      
	public void method2(){      
       synchronized(Foo.class)   //  class literal(类名称字面常量)      
	}   
	public static void method3() {
       synchronized(o){     
       }
    }
    public static void method4() {     
        //..........     
        try {     
            synchronized (Class.forName("Foo")) {     
              //............     
            }     
        } catch (ClassNotFoundException ex) {     
        }     
        //.............     
    }    
}

代码中的四个方法都是把class literal作为锁的情况，他和同步的static函数产生的效果是相同的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不相同，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。