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:0
Thread1:1
Thread1:2
Thread1:3
Thread1:4
Thread2:5
Thread2:6
Thread2:7
Thread2:8
Thread2:9

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

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

thread1.start();
thread2.start();

输出结果：

Thread2:0
Thread1:0
Thread2:1
Thread1:1
Thread2:2
Thread1:2
Thread2:3
Thread1:3
Thread2:4
Thread1: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:0
Thread2:1
Thread1:1
Thread2:2
Thread2:2
Thread1:2
Thread2:3
Thread1:3
Thread1:4
Thread2: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