本系列译自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得了一套完整的并发工具类，以帮助开发人员实现更细粒度的并发控制，而不是同步的。