并发编程中synchronized一直是元老级角色，我们称之为重量级锁。主要用在三个地方：

1、修饰普通方法，锁是当前实例对象。

2、修饰类方法，锁是当前类的Class对象。

3、修饰代码块，锁是synchronized括号里面的对象。

一、synchronized实现原理

当一个线程试图访问同步代码块时，必须得到锁。在退出或抛出异常时必须释放锁，JVM是基于进入和退出Monitor来实现方法同步和代码块同步。

我们来看下synchronized的字节码：

public class SynchronizedTest{    public void addNum1(String userName)    {    }        public void addNum2(String userName)    {        synchronized(this)        {        }    }        public synchronized void addNum3(String userName)    {    }}

在字节码里可以看到，用synchronizde修饰的同步代码块多了两个指令：monitorenter、monitorexit；

代码块同步是使用monitorenter、monitorexit指令实现的，而方法同步是使用另外一种方式实现的，但是方法同步也可以使用这两个指令来实现。

monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit是插入到方法的结束和异常位置。任何一个对象都有一个monitor与之关联。线程执行到monitorenter指令处时，会尝试获取对象所对应的monitor所有权，即尝试获得对象的锁。

二、修饰普通方法 锁是当前实例对象

我们先来看下将实例对象作为锁的概念：

public class AddNumTest{    private int num = 0;        public synchronized void addNum(String str)    {        try        {            if ("a".equals(str))            {                num = 10;                System.out.println("add a");                Thread.sleep(2000);            }            else            {                num = 20;                System.out.println("add b");            }            System.out.println(str + " num = " + num);        }        catch (InterruptedException e)        {            e.printStackTrace();        }    }}

public class AddNumThreadOne implements Runnable{    private AddNumTest at;        public AddNumThreadOne(AddNumTest at)    {        this.at = at;    }    @Override    public void run()    {        at.addNum("a");    }}

public class AddNumThreadTwo implements Runnable{    private AddNumTest at;    public AddNumThreadTwo(AddNumTest at)    {        this.at = at;    }        @Override    public void run()    {        at.addNum("b");    }}

public class AddNum{    public static void main(String[] args)    {        //注意，这里传入同一个实例对象        AddNumTest at = new AddNumTest();        //AddNumTest bt = new AddNumTest();        Thread t1 = new Thread(new AddNumThreadOne(at));        Thread t2 = new Thread(new AddNumThreadTwo(at));        t1.start();        t2.start();    }}

执行结果：

add aa num = 10add bb num = 20

前面解释过关键字synchronized的实现原理是使用对象的monitor来实现的，取的锁都是对象锁，而不是把一段代码或者函数作为锁。在并发情况下，如果并发情况下多线程竞争的是同一个对象，那么先来的获取该对象锁，后面的线程只能排队，等前面的线程执行完毕释放锁。

上面介绍的是同一个对象锁，我们来观察下获取不同的对象锁会是什么情况：

public static void main(String[] args)    {        //注意，这里传入的不同的实例对象        AddNumTest at = new AddNumTest();        AddNumTest bt = new AddNumTest();        Thread t1 = new Thread(new AddNumThreadOne(at));        Thread t2 = new Thread(new AddNumThreadTwo(bt));        t1.start();        t2.start();    }

执行结果：

add aadd bb num = 20a num = 10

这里线程1、2抢占的是不同的锁，尽管线程1先到达同步代码块的位置，但是由于monitor不一样，所以不能阻塞线程2的执行。

三、synchronized锁重入

锁重入：当一个线程得到一个对象锁后，再次请求此对象锁时可以再次得到该对象的锁。但是这里有维护一个计数器，同一个线程每次得到对象锁计数器都会加1，释放的时候减1，直到计数器的数值为0的时候，才能被其他线程所抢占

public class AgainLock{    public synchronized void print1()    {        System.out.println("do work print1");        print2();    }        public synchronized void print2()    {        System.out.println("do work print2");        print3();    }        public synchronized void print3()    {        System.out.println("do work print3");    }}

public class AgainLockTest{    public static void main(String[] args)    {        Thread t = new Thread(new Runnable()        {            @Override            public void run()            {                AgainLock al = new AgainLock();                al.print1();            }        });        t.start();    }}

执行结果：

do work print1do work print2do work print3

这里面三个同步方法，使用的锁都是该实例对象的同步锁，同一个线程在执行的时候，每次都是在锁没有释放的时候，就要重新再去获取同一把对象锁。从运行结果可以看出，关键字synchronized支持同一线程锁重入。

四、synchronized同步代码块

用synchronized同步方法的粒度过大，有时候一个方法里面的业务逻辑很多，但是我们想对同步的部分进行单独定制，这时候就可以使用synchronized来同步代码块。

public class SynchronizedTest1{    public void doWorkTask()    {        for(int i=0;i<100;i++)        {            System.out.println("nosynchronized thread name =" + Thread.currentThread().getName()                + ";i=" + i);        }        synchronized(this)        {            for(int i=0;i<100;i++)            {                System.out.println("thread name =" + Thread.currentThread().getName()                    + ";i=" + i);            }        }    }}

如果在并发情况下，调用这个类的同一个实例，线程A和B可以同时执行使用synchronized同步之前的代码逻辑，但是使用关键字同步的部分是互斥的，先到达的线程占有对象锁，后面的线程会被阻塞，直到对象锁被前面的线程释放。

本文转自xsster51CTO博客，原文链接： http://blog.51cto.com/12945177/1948502，如需转载请自行联系原作者