Java 并发/多线程教程(十二)-JAVA同步块-CSDN博客

本系列译自jakob jenkov的Java并发多线程教程，个人觉得很有收获。由于个人水平有限，不对之处还望矫正！

一个Java同步块标记一个方法或一个代码块作为同步。可以使用Java同步块来避免竞态条件。

java同步关键字

在Java中同步的块被标记为Synchronized关键字。Java中的同步块在某些对象上是同步的。在同一对象上同步的所有同步块只能在同一时间内执行一个线程。所有试图进入同步块的其他线程都被阻塞，直到同步块中的线程退出该块.

Synchronized关键字可以用来标记四种不同类型的块:

1、实例方法

2、静态方法

3、实例方法中的代码块

4、静态方法中的代码块

这些块在不同的对象上是同步的。你需要哪种类型的同步块取决于具体的情况

同步实例方法

下面是一个同步实例方法

public synchronized void add(int value){

this.count +=value;

}

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

Java中的同步实例方法在拥有该方法的实例(对象)上同步。因此，每个实例的同步方法都在不同的对象上同步:拥有实例。只有一个线程可以在同步的实例方法中执行。如果存在多个实例，那么每次一个线程可以在每个实例的同步实例方法中执行。每个实例一个线程。

同步静态方法

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

public static synchronized void add(int value){

count += value;

}

同样在这里，synchronized关键字告诉Java，该方法是同步的。

同步静态方法在类的类对象上同步。由于每个类只存在一个类对象，所以只有一个线程可以在同一个类中执行静态同步方法。

如果静态同步方法位于不同的类中，那么一个线程可以在每个类的静态同步方法中执行。

实例方法中的同步块

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

下面是一个非同步Java方法中Java代码的同步块:

public void add(int value){

synchronized(this){

this.count += value;

}

}

这个例子使用Java同步块构造来标记一个代码块作为同步。这段代码现在执行起来就像一个同步的方法一样,请注意Java同步块构造如何在圆括号中使用对象。在这个例子中，使用了“this”，也就是调用add方法的实例。被同步构造的圆括号中的对象称为监视器对象。代码被认为是在监视器对象上同步的。同步的实例方法使用它所属的对象作为监视器对象,只有一个线程可以在同一个监视器对象上同步执行一个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);

}

}

}

因此，只有一个线程可以在这个示例中的两个同步块中的任何一个中执行。如果第二个同步块在一个不同的对象上被同步，那么一次一个线程就能够在每个方法中执行。

静态方法中的同步块

下面是静态方法的两个例子。这些方法在类的类对象上是同步的:方法属于:

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(this){

log.writeln(msg1);

log.writeln(msg2);

}

}

}

在这两种方法中，只有一个线程可以同时执行。如果第二个同步块在一个不同的对象上被同步，而不是MyClass类，然后一个线程可以同时在每个方法内执行。

Java同步的例子

这里有一个例子，它启动了两个线程，并让它们都在同一个计数器实例上调用add方法。一次只有一个线程能够在同一个实例上调用add方法，因为这个方法在它所属的实例上是同步的。

public class Counter{

long count = 0;

public synchronized void add(long value){

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();

ThreadthreadA = new CounterThread(counter);

ThreadthreadB = new CounterThread(counter);

threadA.start();

threadB.start();

}

}

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

如果这两个线程引用了两个单独的计数器实例，那么就不会同时调用add()方法了。调用的对象应该是不同的对象，因此调用的方法也会在不同的对象上同步(拥有该方法的对象)。因此，通话不会阻塞。这就是它的样子:

public class Example {

public static void main(String[] args){

Counter counterA = new Counter();

Counter counterB = new Counter();

ThreadthreadA = new CounterThread(counterA);

ThreadthreadB = new CounterThread(counterB);

threadA.start();

threadB.start();

}

}