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

本系列译自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();

        }

}

注意两个线程，threadA和threadB，不再引用相同的计数器实例。countA和countB的添加方法在它们的两个拥有实例上是同步的。调用add()在countA将不会阻塞在countB对add()的调用。

Java并发的效率

同步机制是Java的第一种用于同步对多个线程共享的对象的访问机制。尽管如此，同步机制并不十分先进。这就是为什么Java 5得了一套完整的并发工具类，以帮助开发人员实现更细粒度的并发控制，而不是同步的。