一、线程安全的概念与synchronized
1、线程安全概念
并发程序开发的一大关注重点就是线程安全，线程安全就是并行程序的根本和根基。使用volatile关键字只能确保一个线程修改数据后，其他线程能够看到这个改动。但是两个线程同时修改某一个数据时，却依然会产生冲突。
下面AccountingVol.java模拟了一个计数器，创建两个线程同时对i进行累加操作，各执行10000000次，我们希望的执行结果时i的值最终可以达到20000000，但是事实并非如此。多次执行代码会发现，有时候i的最终值会小于20000000。这就是因为两个线程同时对i写入时，其中一个线程的结果会覆盖另一个线程的结果（虽然这个时候i被声明为volatile变量）
public class AccountingVol implements Runnable
{
static AccountingVol instance = new AccountingVol();
static volatile int i = 0;
public static void increase()
{
++i;
}
@Override
public void run()
{
for (int j = 0; j < 10000000; ++j)
{
increase();
}
}
public static void main(String[] args) throws InterruptedException
{
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
多次执行代码会发现，有时候i的最终值会小于20000000。
之所以会出现这种情况，是因为出现了下图的冲突。线程t1和线程t2读取i为0，并各自计算得到i=1,最后各自写入这个结果。虽然++i被执行了2次，但实际i的值只增加了1.
2、synchronized关键字
要从根本上解决上述问题，就必须保证多个线程在对i进行操作时完全同步。也就是说，当线程A在写入时，线程B不仅不能写，同时也不能读。因为在线程A写完之前，线程B读取的一定是一个过期的数据。Java中提供了一个重要的关键字synchronized来实现这个功能。
关键字synchronized的用法：
（1）指定加锁对象：对给定的对象加锁，进入同步代码块前要获得给定对象的锁。
（2）直接作用与实例方法：相当于对当前实例加锁，进入实例方法前需要获得当前实例的锁。
（3）直接作用于静态方法：相当于对当前类加锁，进入类方法前需要获得当前类的锁
下面AccountingVol2.java通过指定加锁对象instance，实现AccountingVol.java的线程安全。多次执行代码会发现，最终值会都等于20000000，说明保证了线程安全。
public class AccountingVol2 implements Runnable
{
static AccountingVol2 instance = new AccountingVol2();
static volatile int i = 0;
@Override
public void run()
{
for (int j = 0; j < 10000000; ++j)
{
synchronized (instance)
{
++i;
}
}
}
//main函数参见AccountingVol.java中的main函数
下面AccountingVol3.java通过直接作用于实例方法，实现AccountingVol.java的线程安全。多次执行代码会发现，最终值会都等于20000000，说明保证了线程安全。
public class AccountingVol3 implements Runnable
{
static AccountingVol3 instance = new AccountingVol3();
static volatile int i = 0;
public synchronized void increase()
{
++i;
}
@Override
public void run()
{
for (int j = 0; j < 10000000; ++j)
{
increase();
}
}
//main函数参见AccountingVol.java中的main函数
下面的AccountingSyncBad.java给出了一种错误的同步方式。虽然在第三行声明increase()方法是一个同步方法，但是执行这段代码的两个线程都指向了不同的Runnnable实例，即这两个线程的Runnable实例并不是同一个对象。因此，线程t1会在进入同步方法前加锁自己的Runnable实例，而线程t2也关注自己的对象锁。换言之，这两个线程使用的是两把不同的锁。因此，无法保证线程安全。
public class AccountingSyncBad implements Runnable
{
static int i = 0;
public synchronized void increase()
{
++i;
}
@Override
public void run()
{
for (int j = 0; j < 10000000; ++j)
{
increase();
}
}
public static void main(String[] args) throws InterruptedException
{
Thread t1 = new Thread(new AccountingSyncBad());
Thread t2 = new Thread(new AccountingSyncBad());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
针对AccountingSyncBad.java中的问题，只需要简单的修改上述代码，就能使其正确执行。那就是使用synchronized的第三种方法，将其作用于静态方法。这样，即使两个线程指向不同的Runnable对象，但由于方法块需要的是当前类的锁，而非当前实例，因此线程还是可以正确同步的。将increase()方法修改如下：
public synchronized static void increase()
{
++i;
}
除了用于线程同步、确保线程安全外，synchronized还可以保证线程的可见性和有序性。
（1）从可见性的角度讲，synchronized可以完全替代volatile的功能，只是使用上没有那么方便。
（2）从有序性的角度来讲，由于synchronized限制每次只有一个线程可以访问同步块，因此无论同步块内的代码如何被乱序执行，只要保证串行语义一致，那么执行结果总是一样的。而其他访问的线程，又必须在获得锁后方能进入代码块读取数据，因此，他们看到的结果并不取决于代码的执行过程，从而有序性得到了解决（换言之，被synchronized限制的多个线程是串行执行的）。
