Java中synchronized关键字的使用

对于关键字synchronized，研究起来，发现还是有许多让自己模糊的地方，网上也有很多篇博客对synchronized关键字的使用讲解的相当好，自己也受益匪浅。自己之所以还写一篇博客来介绍synchronized的目的只有一个：加深自己对synchronized的理解。

写博客有时候确实是一个好的东西，往往研究某个知识点的时候，自己觉得弄懂了，但是过几天查不多就忘了模糊了，而写博客可以增加对知识点的理解和加深知识的记忆。

synchronized关键字是解决多线程并发同步的方法之一。

synchronized可以修饰如下几个方面。

1、修饰一个代码块，作用的对象是调用这个代码块的对象

2、修饰一个方法，作用的对象是调用这个方法的对象

3、修饰一个静态方法，作用的对象是静态方法所属的类的所有对象

4、修饰一个类，作用的对象是该类的所用对象。

下面一一进行介绍

1、synchronized修饰一个代码块

1.1 一个线程访问一个对象obj中的synchronize(this)同步代码块时，其它线程试图访问该对象obj的synchronize(this)同步块时将会被阻塞。

看下面这个例子

Demo1

    class MyThread implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {synchronized(this){for(int i =0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running .....");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}}

测试代码如下：

    public class SyncCodeBlock {public static void main(String[] args) {MyThread mt = new MyThread();new Thread(mt,"Thread1").start();new Thread(mt,"Thread2").start();}}

运行结果：

Thread2  running .....
Thread2  running .....
Thread2  running .....
Thread1  running .....
Thread1  running .....
Thread1  running .....

这里，名字为Thread1、Thread2的两个线程都想访问对象mt的同步块synchronized(this),由于只有一个锁，谁拿到的这个锁就该谁访问，也就是说，在任一时刻只能有一个线程访问这一同步代码块。例如，当Thread1线程拿到锁正在执行run里面的代码时，名字为Thread2的线程也想访问同一对象mt的同步块synchroized(this)的同步块将会被阻塞，只有等Thread1访问结束之后释放该对象锁Thread2拿到该对象锁才能访问。

如果我们将测试代码该为如下：

    public static void main(String[] args){MyThread mt = new MyThread();MyThread mt2 = new MyThread();new Thread(mt,"Thread1").start();new Thread(mt2,"Thread2").start();}

结果如下：

Thread2  running .....
Thread1  running .....
Thread2  running .....
Thread1  running .....
Thread2  running .....
Thread1  running .....

这里，和上面的第一种测试代码不同，这里有两个不同的MyThread对象，分别对应着两把锁，因此线程Thread1访问同步块是去拿对象mt的锁，而线程Thread2访问同步块是去拿对象mt2的锁，而这两个锁是没有任何关系的，即线程Thread1执行的是对象mt的中的synchronized代码块，而线程Thread2执行的是对象mt2中的synchronized代码块，两者互不相关，因此这两个线程就可以同时进行。

小结：当一个线程访问一个对象obj中的synchronized(this)同步块时，其它线程访问这个对象obj的synchronize(this)就会阻塞

1.2 当一个线程访问一个对象obj中的synchronized(this)同步代码块时，其它的线程可以同时访问该对象obj中的非synchronize(this)代码块

看一个例子

Demo2：多个线程访问synchronized和非synchronized代码块

    class MyThread implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {String name = Thread.currentThread().getName();if(name.equals("Thread1")){synMethod();}else if(name.equals("Thread2")){notSynMethod();}}public void synMethod(){synchronized(this){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+"running ....");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}public void notSynMethod(){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+"running ....");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}

测试代码：

public static void main(String[] args) {MyThread mt = new MyThread();new Thread(mt,"Thread1").start();new Thread(mt,"Thread2").start();}

运行结果：

Thread1 running ....
Thread2 running ....
Thread1 running ....
Thread2 running ....
Thread1 running ....
Thread2 running ....

分析：

上面的代码中，有一个使用synchronize(this)同步的方法synMethod，有一个没有使用关键字synchronize(this)同步的方法notSynMethod.

由于线程Thread1和Thread2没有同时访问对象mt的synchronized(this)同步代码块，而是只有Thread1访问，Thread2访问的是对象mt非synchronized(this)代码块。因此这两个线程是可以同时进行的。

注意：这里的“访问对象mt的非synchronized(this)代码块”并不是单单指对象mt中没有用关键字synchronized修饰的代码块，而是还包括对象mt中其它使用类似synchronized(otherRef)修饰的代码块,其中otherRef为不等于this的其它引用对象。

看下面的例子，将上例Demo2中的notSynMethod方法用synchronized(otherRefe)来同步

    private int [] value = new int[0];public void notSynMethod(){synchronized(value){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running ....");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}

改成这样，线程Thread1、Thead2依然可以同时工作，这是因为他们所需要的锁不一样。

小结：当一个线程访问对象obj的synchronized(this)代码块时，其它线程是可以同时访问该对象obj的非synchronized(this)的代码块

1.3、当多线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞

看一个例子：MyThread5类中的两个方法都使用了synchronized(this)来进行修饰.

    class MyThread5 implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {String name = Thread.currentThread().getName();if(name.equals("Thread1")){synMethod();}else if(name.equals("Thread2")){synMethod2();}}public void synMethod(){synchronized(this){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running ....");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}public void synMethod2(){synchronized(this){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running ...." + i);try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}}}

测试方法为：

    public static void main(String[] args) {MyThread5 mt = new MyThread5();new Thread(mt,"Thread1").start();new Thread(mt,"Thread2").start();}

运行结果：

Thread2 running ....0
Thread2 running ....1
Thread2 running ....2
Thread1 running ....
Thread1 running ....
Thread1 running ....

分析：

当线程Thread1访问对象mt的方法synMethod中的synchronized(this)同步代码块时，线程Thread2访问对象mt中另一个方法synMethod2中synchronized(this)同步代码块的访问将被阻塞。这是因为，线程Thread1访问mt的一个synchronized(this)同步代码块时，它就获得了这个mt的对象锁。结果，线程Thread2对该mt对象所有使用synchronized(this)的同步代码部分的访问都被暂时阻塞。

2、synchronized修饰某个方法

synchronized修饰某个方法，作用的对象为调用该方法的对象。

其实，

    public synchronized void method(){//to do something ....}

效果等同于：

    public void method(){synchronized(this){//to do something ....}}

因此，这里不再进行介绍。

不过，有两点需要注意的是

1、一般我们不建议同步整个方法，能同步方法中的某个代码块就同步代码块。同步安全往往是以性能为代价的。

2、synchronized关键字同步的方法不能继承。虽然可以使用synchronized来修饰某个方法，但是synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。

3.synchronized关键字修饰静态代码块

synchronized关键字修饰静态代码块，作用的是该类的所用对象。

Demo3:synchronized关键字修饰静态代码块

    class MyThread2 implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {print();}public synchronized static void print() {for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running... "+i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}

测试代码：

    public static void main(String[] args) {MyThread2 mt = new MyThread2();MyThread2 mt2 = new MyThread2();new Thread(mt,"Thread1").start();new Thread(mt2,"Thread2").start();}

分析：

我们都知道静态方法是属于类的，不是属于对象的。

MyThread2类中的静态方法print使用了synchronized修饰，尽管在测试代码中使用了两个不同的对象mt/mt2,但是这里的锁不再是锁对象mt/mt2.而是锁”类MyThread2”这个对象，mt/mt2都是属性类MyThread的，因此mt/mt2就相当于同一把锁。，因此，这两个线程在访问此静态方法print时就需要取得锁之后才能访问，访问完之后释放锁。

4、synchronized修饰一个类

synchronized修饰一个类，作用为该类的所用对象

    class MyThread3 implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {synchronized(MyThread3.class){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running... "+i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}}

测试代码如下：

    public static void main(String[] args) {MyThread3 mt = new MyThread3();MyThread3 mt2 = new MyThread3();new Thread(mt,"Thread1").start();new Thread(mt2,"Thread2").start();}

运行结果如下：

Thread2 running... 0
Thread2 running... 1
Thread2 running... 2
Thread1 running... 0
Thread1 running... 1
Thread1 running... 2

由于mt/mt2都是属于类MyThread3的，而synchronized修饰的是MyThread3这整个类，因此所有的MyThread访问此代码块都是互斥的，任一时刻都只能有一个线程能够访问。

不知道大家有没有这样的疑问，反正我是有的，既然synchronized修饰的静态方法和修饰的整个类都是作用与该类的全部对象，那么这两者是不是互斥的呢？？

上面的问题具体一点来描述：有一个MyThread类，MyThread类中的一个方法中的代码块Block1用synchronize(MyThread.class)同步，MyThread类中一个静态方法method用synchronized同步，有两个线程Thread1、Thread2，Thread1访问Block1，Thread2访问method是否可以同时进行？？？

答案是：不可以，这是因为都作用与该类的所用对象，锁是同一个锁，是互斥的，不可以同时访问

看如下的例子

    class MyThread4 implements Runnable{
    private static final int NUM = 3;@Overridepublic void run() {String name = Thread.currentThread().getName();if(name.equals("Thread1")){synClassMethod();}else if(name.equals("Thread2")){synStaticCodeBlock();}}public void synClassMethod(){synchronized(MyThread4.class){for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running... "+i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}public  synchronized static void synStaticCodeBlock(){    for(int i=0;i<NUM;i++){System.out.println(Thread.currentThread().getName()+" running... "+i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}

测试代码如下：

    public static void main(String[] args) {MyThread4 mt = new MyThread4();MyThread4 mt2 = new MyThread4();new Thread(mt,"Thread1").start();new Thread(mt2,"Thread2").start();}

运行结果为：

Thread1 running... 0
Thread1 running... 1
Thread1 running... 2
Thread2 running... 0
Thread2 running... 1
Thread2 running... 2

总结

1、当两个线程Thread1、Thread2访问一个对象obj的synchronized(this)代码块时，每个时刻都只能有一个访问此代码块，当Thread1访问时，Thread2只有在Thread1线程执行完这段代码块并释放锁后取得锁才能访问。

2、当两个线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它的线程可以访问对象obj的非synchronized(this)代码块。

3、当多线程并发时，一个线程访问对象obj的synchronized(this)代码块时，其它线程对对象obj中所有其他synchronized(this)同步代码块的访问将被阻塞。这是因为，当一个线程访问obj的一个synchronized(this)同步代码块时，它就获得了这个obj的对象锁。结果，其它线程对该obj对象所有同步代码部分的访问都被暂时阻塞。

4、第3个结论同样适用其它同步代码块。例如，如果一个线程访问对象lock的synchronized(lock)的同步代码块，其中private int[] lock = new int[0]，则其它线程在在其它方法中出现的
synchronized(lock)的同步代码块的访问将被阻塞。

5、上面所有的结论都适用于其它对象锁。

《java笔记系列》synchronized

Java中synchronized关键字的使用

1、synchronized修饰一个代码块

2、synchronized修饰某个方法

3.synchronized关键字修饰静态代码块

4、synchronized修饰一个类

总结