Java中的synchronized

最近发现自己对synchronized不怎么熟悉，就在网上找了下相关文章，做个笔记，文末有参考的文章链接

作用

---

1.修饰一个代码块，被修饰的代码块称为同步语句块，起作用的范围是{}大括号括起来的代码，作用的对象是调用这个代码块的对象。

2.修饰一个方法

3.修饰一个静态方法,synchronized修饰的静态方法锁定的是这个类的所有对象

4.修饰一个类

修饰一个代码块

---

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

public class SyncThread implements Runnable{    private int counter;    public SyncThread(){        counter = 0;    }    @Override    public void run() {        synchronized (this){            for (int i= 0; i< 5;i++){                try {                    System.out.println(Thread.currentThread().getName()+":" + (counter++));                    Thread.sleep(100);                }catch (Exception e){                    e.printStackTrace();                }            }        }    }    public int getCounter(){        return counter;    }}

测试代码：

        SyncThread syncThread = new SyncThread();        Thread thread1 = new Thread(syncThread,"Thread1");        Thread thread2 = new Thread(syncThread,"Thread2");        thread1.start();        thread2.start();

输出结果：

Thread1:0Thread1:1Thread1:2Thread1:3Thread1:4Thread2:5Thread2:6Thread2:7Thread2:8Thread2:9

稍作修改一下，将测试代码改成如下所示：

SyncThread syncThread = new SyncThread();Thread thread1 = new Thread(new SyncThread(),"Thread1");Thread thread2 = new Thread(new SyncThread(),"Thread2");thread1.start();thread2.start();

输出结果：

Thread2:0Thread1:0Thread2:1Thread1:1Thread2:2Thread1:2Thread2:3Thread1:3Thread2:4Thread1:4

当一个线程访问对象的synchronized(this)同步代码块时，另一个线程仍然可以访问该对象的非synchronized(this)的部分

public class Counter implements Runnable{    private int counter;    public Counter(){        counter = 0;    }    @Override    public void run() {        String threadName = Thread.currentThread().getName();        if ("Thread1".equals(threadName)){            counterAdd();        }else if ("Thread2".equals(threadName)){            printCounter();        }    }    public void counterAdd(){        synchronized (this){            for (int i= 0 ;i < 5;i++){                try {                    System.out.println(Thread.currentThread().getName() + ":" + (counter++));                    Thread.sleep(100);                }catch (Exception e){                    e.printStackTrace();                }            }        }    }    public void printCounter(){        for (int i =0;i<5;i++){            try {                System.out.println(Thread.currentThread().getName() + ":" + counter);                Thread.sleep(100);            }catch (Exception e){                e.printStackTrace();            }        }    }}

测试代码：

        Counter counter = new Counter();        Thread thread1 = new Thread(counter,"Thread1");        Thread thread2 = new Thread(counter,"Thread2");        thread1.start();        thread2.start();

输出结果：

Thread1:0Thread2:1Thread1:1Thread2:2Thread2:2Thread1:2Thread2:3Thread1:3Thread1:4Thread2:5

注意：
1.这里的示例代码为了简单，就没有注意执行时间的问题，所以输出的结果有一定的不确定行，可以自行调整sleep时间来完善。

2.如果将变量改成静态变量，那么执行的结果也就不一样，因为静态变量属于类。

给指定的对象加锁

public void methodName(YourObject object){        synchronized (object){            //write your code here        }    }

这种方式，其实和this方式原理上是一样的，this代表的也是该类的一个对象，用在不同的地方而已。

不指定具体对象的锁

当没有明确的对象作为锁时，只想让一段代码同步时，可以创建一个特殊的对象作为锁。

public class Any implements Runnable{    //长度为0的byte数组对象创建的开销较小，    // 查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，    // 而Object lock = new Object()则需要7行操作码。    private byte[] lock = new byte[0];    @Override    public void run() {        synchronized (lock){        }    }}

synchronized修饰一个方法

---

修饰一个方法，和修饰一个代码块是一样的，只不过作用域不同而已。修饰方法，作用域是整个方法，修饰代码块，作用域是代码块的内容。

因此修饰一个方法，可以有以下两种写法：

写法1:

public synchronized void method(){   // todo}

写法2:

public void method(){   synchronized(this) {      // todo   }}

synchronized关键字不能继承

如果在父类中的某个方法使用了synchronized关键字，那么在子类中覆盖改方法，改方法在子类中并不是同步的，必须显示的海上synchronized关键字才行。

或者，在子类方法在中调用父类的同步方法。

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

在子类方法中添加synchronized

class Parent {   public synchronized void method() { }}class Child extends Parent {   public synchronized void method() { }}

在子类方法中调用父类synchronized方法

class Parent {   public synchronized void method() {   }}class Child extends Parent {   public void method() { super.method();   }}

修饰一个静态方法

---

public synchronized static void methodName(){    }

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

修饰一个类

---

class ClassName {   public void method() {      synchronized(ClassName.class) {         // todo      }   }}

synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁

总结

---

A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。

B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

参考文章：

1.http://blog.csdn.net/luoweifu/article/details/46613015