synchronized用法的分析和总结

在多线程环境中并发访问资源时会产生不可意料的结果，防止这种冲突的产生是当资源被一个任务使用时，在其上加锁。第一个访问某个资源的任必需锁定这个资源，使其它任务在资源未被解锁之前无法访问它。而其在被解锁之时另一个任务即可以锁定并使用它，每个任务锁定的资源都是最新的结果。

Java提供Synchronized关键字，为防止资源冲突提供了内置支持

锁机制有如下两种特性

1. 互斥性，同一时间只允许一个线程访问共享资源
2. 可见性，锁在被释放之前对共享变量的修改，对随后取得该锁的另一个线程是可见的

可以根据锁的作用范围浅显的把锁分为类锁和对象锁

类锁：
它表示的是给Class类上锁，类锁对类的所有对象实例都起作用，Class类是一个特殊的类，它包含了与类有关的信息，使用如下方式加锁时就是类锁，它表示这个类同一时间只能被一个线程使用。

• Synchronized(类.class){}
• 静态方法和静态对象

对象锁：
所有的对象都含有单一的锁（也称为监视器锁），当在对象上调用其任意synchronized方法时，此对象都被加锁。它表示一个对象实例在同一时间只能被一个线程使用。

• Synchronized(this|object){}
• 修饰非静态方法

对象锁的验证
下图两个线程共用一个Runnable对象，test1和test2是两个普通的方法

public class TestMain {    public static void main(String arg[]) {        SyncThread target = new SyncThread();        Thread thread1 = new Thread(target, "SyncThread1");        Thread thread2 = new Thread(target, "SyncThread2");        thread1.start();        thread2.start();    }}

public class SyncThread implements Runnable {    private static int count;    private final byte[] lock = new byte[0];    public SyncThread() {        count = 0;    }    @Override    public void run() {        if (Thread.currentThread().getName().contains("1")) {            test1();        } else if (Thread.currentThread().getName().contains("2")) {            test2();        }    }    private void test1() {        for (int i = 0; i < 5; i++) {            try {                System.out.println(Thread.currentThread().getName() + ": " + (count++));                Thread.sleep(500);            } catch (Exception e) {                e.printStackTrace();            }        }    }    private void test2() {        for (int i = 0; i < 5; i++) {            try {                System.out.println(Thread.currentThread().getName() + ": " + (count++));                Thread.sleep(500);            } catch (Exception e) {                e.printStackTrace();            }        }    }}

从打印结果可以看出test1和test2方法执行是不同步的。

SyncThread2: 0SyncThread1: 0SyncThread1: 1SyncThread2: 2SyncThread1: 3SyncThread2: 4SyncThread2: 5SyncThread1: 5SyncThread1: 6SyncThread2: 6

当把test1和test2写成普通的同步方法时，我们再来看看打印的结果

 private synchronzied void test1() {    ... }

 private synchronzied void test2() {    ... }

SyncThread1: 0SyncThread1: 1SyncThread1: 2SyncThread1: 3SyncThread1: 4SyncThread2: 5SyncThread2: 6SyncThread2: 7SyncThread2: 8SyncThread2: 9

可以看出两个线程是按顺序执行的，thread1执行完了才轮到thread2执行。当test1还没执行完时，target对象被锁住，test2处于等待的状态，直到test1释放锁的时候test2才能执行。所以对于某个特定的对象而言，其所有Synchronized方法共享同一个锁。

当test1和test2改成是同步控制块时，打印结果和上面是一样的，这种情况锁住的也是对象本身。使用同步控制块而不是同步方法，可以使多个任务访问对象的时间性能得到提高，平常使用时建议尽量使用同步控制块。

 private void test1() {    synchronzied(this|lock){        ...    } }

 private void test2() {    synchronzied(this|lock){        ...    } }

synchronized锁重入
上面的测试中还应用到了synchronized锁重入的功能，它表示的是当一个线程得到一个对象锁后，再次请求次对象锁时是可以再次得到该对象当锁的。假如没有锁重入的话，就会造成死锁。

当一个对象上的不同方法锁住的是不同的对象时，各自的锁互相独立，下面把test1在this对象上同步，test在lock对象上同步。

 private void test1() {    synchronzied(this){        ...    } }

 private void test2() {    synchronzied(lock){        ...    } }

从打印结果可以看出，test1和test2的执行变成不同步了。因而在使用synchronized时要注意同步的对象。

SyncThread1: 0SyncThread2: 1SyncThread1: 2SyncThread2: 3SyncThread1: 4SyncThread2: 5SyncThread1: 6SyncThread2: 6SyncThread1: 7SyncThread2: 8

类锁的验证
需要注意的是，以上同步的条件是test1和test2处于同一个对象，当它们不是处于同一个对象时是不同步的

  public static void main(String arg[]) {        SyncThread target = new SyncThread();        Thread thread1 = new Thread(new SyncThread(), "SyncThread1");        Thread thread2 = new Thread(new SyncThread(), "SyncThread2");        thread1.start();        thread2.start();    }

把测试方法改成thread1和thread2不共用一个Runnable，打印结果如下

SyncThread1: 0SyncThread2: 1SyncThread1: 2SyncThread2: 2SyncThread1: 3SyncThread2: 3SyncThread1: 4SyncThread2: 4SyncThread1: 5SyncThread2: 5

要想在不同对象也能同步，要实现的是类锁。针对每个类，也有一个锁（作为类的Class对象的一部分）
在main方法里还是继续用不同的Runnable对象

Thread thread1 = new Thread(new SyncThread(), "SyncThread1");Thread thread2 = new Thread(new SyncThread(), "SyncThread2");

把test1和test2改成如下静态的同步方法

private static synchronized void test1() {   ...}

private static synchronized void test2() {   ...}

打印结果如下，这个就印证了static synchronized方法的锁是类锁，所以static synchronized可以防止在类的范围内防止并发数据对static数据的并发访问

SyncThread1: 0SyncThread1: 1SyncThread1: 2SyncThread1: 3SyncThread1: 4SyncThread2: 5SyncThread2: 6SyncThread2: 7SyncThread2: 8SyncThread2: 9

test1和test2写成如下形式时和静态同步方法的结果和上面的static方法是一样的，这种用法锁住的是Class类

private void test1() {    synchronzied(SyncThread.class|静态对象){        ...    } }

private void test1() {    synchronzied(SyncThread.class|静态对象){        ...    } }

最后说一下什么时候应该使用同步机制，假如你正在写一个变量，它可能接下来被另一个线程读取，或者者正在读取一个上一次已经被另一个线程写过的变量，那么你必需使用同步方法。