Java Synchronized Blocks

最新推荐文章于 2025-06-09 22:36:20 发布

WaterRice(lq)

最新推荐文章于 2025-06-09 22:36:20 发布

阅读量347

点赞数

分类专栏： Java 文章标签： java

Java 专栏收录该内容

9 篇文章

订阅专栏

Java Synchronized Blocks

Java Synchronized Blocks

Java Synchronized Blocks

Java synchronized块将方法或代码块标记为已同步。 Java synchronized块可避免竞态的出现。

The Java Synchronized Keyword

Java中的同步块使用synchronized关键字标记。 Java中的同步块在某个对象上同步。在同一对象上同步的所有同步块只能同时在其中执行一个线程。尝试进入同步块的所有其他线程都被阻塞，直到同步块内的线程退出块。

synchronized关键字可用于标记四种不同类型的块：

Instance methods
Static methods
Code blocks inside instance methods
Code blocks inside static methods

您需要哪种类型的同步块取决于具体情况。

Synchronized Instance Methods

这是一个同步的实例方法：

public synchronized void add(int value) {
	this.count += value;
}

请注意在方法声明中使用synchronized关键字。这告诉Java该方法是同步的。

Java中的同步实例方法在拥有该方法的实例（对象）上同步。因此，每个实例的同步方法在不同的对象上同步：拥有实例。只有一个线程可以在同步实例方法中执行。

Synchronized Static Methods

静态方法被标记为synchronized，就像使用synchronized关键字的实例方法一样。这是一个Java synchronized静态方法示例：

public static synchronized void add(int val) {
	count += val;
}

此处，synchronized关键字告诉Java该方法已同步。

同步静态方法在同步静态方法所属的类的类对象上同步。由于每个类在Java VM中只存在一个类对象，因此在同一个类中的静态同步方法中只能执行一个线程.

如果静态同步方法位于不同的类中，则一个线程可以在每个类的静态同步方法内执行。每个类一个线程，无论它调用哪个静态同步方法。

Synchronized Blocks in Instance Methods

您不必同步整个方法。有时最好只同步方法的一部分。方法中的Java同步块使这成为可能。

这是一个非同步实例方法中的同步Java代码块：

public void add(int val) {
	synchronized(this) {
		this.count += value;
	}
}

此示例使用Java synchronized块构造将代码块标记为已同步。此代码现在将像执行同步方法一样执行.

请注意Java synchronized块构造如何在括号中获取对象。在示例中，使用“this”，这是调用add方法的实例。由synchronized构造在括号中获取的对象称为监视器对象。代码在监视器对象上同步。同步实例方法使用它所属的对象作为监视对象。

只有一个线程可以在同一监视器对象上同步的Java代码块内执行。

以下两个示例在它们被调用的实例上同步。因此，它们在同步方面是等效的：

public class MyClass {
	
	public synchronized void log1(String msg1, String msg2) {
		log.writeln(msg1);
		log.writeln(msg2);
	}

	public void log2(String msg1, String msg2) {
		synchronized(this) {
			log.writeln(msg1);
			log.writeln(msg2);
		}
	}
}

因此，在这个例子中，只有一个线程可以在两个同步块中的任何一个内执行。

如果第二个同步块在与此不同的对象上同步，则一次只有一个线程就能够在每个方法内执行。

Synchronized Blocks in Static Methods

以下是与静态方法相同的两个示例。这些方法在方法所属的类的类对象上同步：

public class MyClass {

	public static synchronized void log1(String msg1, String msg2) {
		log.writeln(msg1);
		log.writeln(msg2);
	}

	public static void log2(String msg1, String msg2) {
		synchronized(MyClass.class) {
			log.writeln(msg1);
			log.writeln(msg2);
		}
	}
}

只有一个线程可以同时在这两个方法中的任何一个内执行。(只有一个类对象)

如果第二个同步块在与MyClass.class不同的对象上同步，那么一个线程可以同时在每个方法内执行。

Java Synchronized Example

下面是一个示例，它启动2个线程并让它们在同一个Counter实例上调用add方法。一次只有一个线程能够在同一个实例上调用add方法，因为该方法在它所属的实例上是同步的。

public class Counter {

	long count = 0;

	public synchronized void add(long val) {
		this.count += value;
	}
}

public class CounterThread extends Thread {

	protected Counter counter = null;

	public CounterThread(Counter counter) {
		this.counter = counter;
	}
	public void run() {
		for(int i = 0; i < 10; i++) {
			counter.add(i);
		}
	}
}

public class Example {
	
	public static void main(String[] args) {
		
		Counter counter = new Counter();
		
		Thread threadA = new CounterThread(counter);
		Thread threadB = new CounterThread(counter);
		
		threadA.start();
		threadB.start();
	}
}

创建了两个线程。相同的Counter实例在其构造函数中传递给它们。 Counter.add()方法在实例上同步，因为add方法是实例方法，并标记为synchronized。因此，只有一个线程可以一次调用add()方法。另一个线程将等到第一个线程离开add()方法，然后才能执行方法本身。

如果两个线程引用了两个单独的Counter实例，那么同时调用add()方法就没有问题。调用将发生在不同的对象上，因此调用的方法也将在不同的对象（拥有该方法的对象）上同步。因此调用不会阻塞。这看起来像这样：

public class Example {
	
	public static void main(String[] args) {
		Counter counter1 = new Counter();
		Counter counter2 = new Counter();
		
		Thread threadA = new MyThread(counter1);
		Thread threadB = new MyThread(counter2);

		threadA.start();
		threadB.start();
	}
}