Java中多线程synchronized的用法

　　在Java中synchronized可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。

　　而synchronized底层是通过使用对象的监视器锁（monitor）来确保同一时刻只有一个线程执行被修饰的方法或者代码块。

对于同步控制，我们需要明确几点：

　　A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

　　B．每个对象只有一个锁（lock）与之相关联。

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

Synchronized修饰的对象：

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

　　2.修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象（对象锁）；

　　3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象（类锁）；

　　4.修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象（类锁）。

　　从上面的锁对象可以看出，Synchronized修饰的锁对象其实就2种：对象锁，类锁。

解释：

　　（1）对象锁：Synchronized修饰非静态方法、代码块（引入的是对象是：非静态变量、非类）；

非静态方法：

public synchronized void method(){// todo}

非静态变量：

private Object o = new Object();
public void method(){
   //o 锁定的对象
   synchronized(o){
    // todo
   }
}

非类（这个可以与类对比，就可以明白）：

public void method(){
 //方法里的this 指的是当前的方法，方法锁
 synchronized(this){
  // todo
 }
}

测试：

　　1）当多个线程使用同一个对象sync1，即：

SyncThread sync1 = new SyncThread();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync1, "thread2");
thread1.start();
thread2.start();

　　因为线程thread1与thread2引入同一个对象sync1，属于同一个锁对象，所以线程执行是按照先执行thread1后释放锁，thread2才能获取锁并执行其方法。

 2）当多个线程使用不同对象sync1与sync2，即：

SyncThread sync1 = new SyncThread();
SyncThread sync2 = new SyncThread();
Thread thread1 = new Thread(sync1, "thread1");
Thread thread2 = new Thread(sync2, "thread2");
thread1.start();
thread2.start();

　　因为线程thread1与thread2引入不同对象sync1与sync2，属于不同锁对象，所以线程thread1与thread2并行执行方法。

 （2）类锁：Synchronized修饰静态方法、代码块（引入的是对象是：静态变量、类）；

静态方法：

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

静态变量：

private static Object o = new Object();
public void method(){
 //o 锁定的对象
 synchronized(o){
  // todo
 }
}

类（与非类对比，就可以明白）：

class SyncThread implements Runnable{
  public void method(){
    synchronized(SyncThread.class){
      // todo 同步代码块
    }
  }
  public void run(){
      method();
  }
}

测试：

　　1）当多个线程使用同一个对象,还是不同对象，即：

Thread thread1 = new Thread(对象1, "thread1");
Thread thread2 = new Thread(对象2, "thread2");
thread1.start();
thread2.start();

　　线程thread1与thread2肯定是按照先后顺序执行，即：先执行thread1后，才能执行thread2。

总结：

　　（1）如果synchronized引入的锁对象是类锁（该类所有的对象同一把锁），那么多个线程访问该锁锁定的功能时，肯定是有先后顺序的，而不能同时执行。

　　（2）如果synchronized引入的锁对象是方法锁，那么多个线程访问该锁锁定的功能时，要区分是是不是同一个锁对象，是同一个锁对象，功能与类锁类似；否则，多个线程可以同时执行该锁锁定的功能。

具体功能详解与代码示例：

1.1修饰代码块

1、synchronized修饰代码块：

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

例子：

public class SyncThread implements Runnable {
  private static int count;
  public SyncThread(){
    count = 0;
  }
  @Override
  public void run() {
    synchronized (this) {  //锁对象是该方法，即方法锁
      for (int i = 0; i < 5; i++) {
        try {
           System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
           Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
      }
    }
   }
  public static int getCount() {
    return count;
  }
}

测试代码：

public class SyncThreadTest {
  public static void main(String[] args) {
    SyncThread sync = new SyncThread();
    Thread thread1 = new Thread(sync, "thread1");
    Thread thread2 = new Thread(sync, "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

结果分析：

　　当并发的2个线程（thread1，thread2）访问同一个对象（sync）中的synchronized代码块时，同一个时刻只能被一个线程访问；而另一个线程只能被堵塞，且必须要等待当前线程访问完，并获取已释放对象锁，才能访问该同步的代码块。线程Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象（同一个对象sync），只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

那怎么才能引入不同的对象？

修改一下测试代码：

public class SyncThreadTest {
   public static void main(String[] args) {
     SyncThread sync1 = new SyncThread();
     SyncThread sync2 = new SyncThread();
     Thread thread1 = new Thread(sync1, "thread1");
     Thread thread2 = new Thread(sync2, "thread2");
     thread1.start();
     thread2.start(); 
   }
}

测试结果：

当前线程名称thread1:0
当前线程名称thread2:1
当前线程名称thread2:3
当前线程名称thread1:2
当前线程名称thread1:4
当前线程名称thread2:5
当前线程名称thread2:6
当前线程名称thread1:7
当前线程名称thread2:8
当前线程名称thread1:9

结果分析：

　　不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行？

　　原因：这时创建了2个SyncThread对象分别为sync1和sync2，线程thread1执行的是对象sync1中的run；而线程thread2执行的是对象sync2中的run。由于2个不同的对象sync1和sync2，synchronized会为它们分别分配2个对象锁，而这2把锁是互不干扰，不形成互斥关系，所以会并行执行。

 2、代码块中引入不同的对象，即指定对象上加锁：（成员变量，类变量-静态变量）

public class SynchronizedObjectDemo {
    //静态的全局变量，类变量(可以是自定义对象)
    private static Object staticObject = new Object();
    //非静态变量，成员变量(可以是自定义对象)
    private Object o = new Object();
    /**
     * 功能描述: <br>
     * 类变量的方法上锁
     */
    public void printStaticObject(){
        synchronized (staticObject) {  //staticObject是静态变量，即类变量上锁
            try {
                //调用线程休眠5秒,锁竞争效果更加明显
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                //输出表示被调用
                System.out.println(System.currentTimeMillis()+" printByStaticObj is called");
            }
        }
    }
    /**
     * 功能描述: <br>
     * 在成员变量上锁的方法
     */
    public void printObj(){
        synchronized (o) { //o是成员变量
            try {
                //调用线程休眠5秒,锁竞争效果更加明显
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                //输出表示被调用
                System.out.println(System.currentTimeMillis()+" printByObj is called");
            }
        }
    }
    
    public static void main(String[] args) {
        //定义一个线程组
        ThreadGroup tgroups = new ThreadGroup(Thread.currentThread().getThreadGroup(), "SynchronizedObjectDemo");
        //循环，每次启动一个线程
        for (int i = 0; i < 5 ; i++) {
            //每一个线程，重新构造对象
            final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo();
            //构造新线程的时候把它加入到定义的线程组
            Thread obj = new Thread(tgroups, new Runnable() {
                @Override
                public void run() {
                    syncObj.printObj();
                }
            });
            obj.start();
        }
        while (true) {//直到定义的线程组中的线程都终止才执行后续步骤
            if(tgroups.activeCount() == 0){
                for (int i = 0; i < 5; i++) {
                    final SynchronizedObjectDemo syncObj = new SynchronizedObjectDemo();
                    //构造新线程的时候把它加入到定义的线程组
                    Thread obj = new Thread(tgroups, new Runnable() {
                        @Override
                        public void run() {
                            syncObj.printStaticObject();
                        }
                    });
                    obj.start();
                }
                break;
            }
        }
    }
}

分析：

　　从这个输出结果可以看出，其实对于一个类变量加锁就类似给静态方法加锁，需要注意的一点是静态方法锁定的是Class对象，而由于类变量全局只有一个，所以行为是类似静态方法，但是锁定的不是同一个对象。

　　同样，而对于一个成员变量加锁就类似给非静态方法加锁。

　　注意：如果把第一次for循环中的SynchronizedObjectDemo对象的构造放到第一次for循环之前的话，输出的结果就会类似第二次for循环了，因为此时锁的是同一个对象。

 除此之外还可以有其他方式指定锁对象：

方式一（作为方法参数）：

public void method3(SomeObject obj){
 //obj 锁定的对象
 synchronized(obj){
   // todo
 }
}

方式二（当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁，如上面的Object对象，但是并不是最经济的方式）：

class Test implements Runnable{
   private byte[] lock = new byte[0];  // 特殊的instance变量
   public void method(){
     synchronized(lock) {
       // todo 同步代码块
     }
   }
   public void run() {
   }
}

　　说明：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

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

 代码示例：

public class Counts implements Runnable {
    private int count;
    public Counts(){
        count = 0;
    }
    //synchronized方法
    public void countAdd(){
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //非synchronized方法,未对count进行写操作，所以可以不用synchronized
    public void countRead(){
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + count);
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            countAdd();
        } else if (threadName.equals("B")) {
            countRead();
        }
    }
}

测试代码：

    public class CountsTest {
        public static void main(String[] args) {
            Counts counter = new Counts();
            Thread thread1 = new Thread(counter, "A");
            Thread thread2 = new Thread(counter, "B");
            thread1.start();
            thread2.start();
        }
    }

测试结果：

当前线程名称A:0
当前线程名称B:1
当前线程名称A:1
当前线程名称B:2
当前线程名称A:2
当前线程名称B:3
当前线程名称A:3
当前线程名称B:3
当前线程名称B:4
当前线程名称A:4

结果分析：

　　上面代码中countAdd是一个synchronized的，countRead是非synchronized的。从上面的结果中可以看出，在线程A访问synchronized的countAdd方法过程中，线程B可以同时访问非synchronized的countRead方法。也就是说：一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块，而不受阻塞。

 1.2修饰方法

1.修饰非静态方法

　　说明：Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，

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

　　synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个方法。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。

 Synchronized作用于整个方法的写法。
写法一：

public synchronized void method(){
   // todo
}

写法二：

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

　　写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

 注意点：

（1）synchronized关键字不能继承。

　　虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分。因此，synchronized关键字不能被继承。

　　如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。

　　当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

示例代码如下：
1）在子类方法中加上synchronized关键字

父类：

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

子类：

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

2）在子类方法中调用父类的同步方法

父类：

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

子类：

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

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

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

 2．修饰静态方法

 代码示例：

    public class StaticMethod implements Runnable{
        private static int count;
        public StaticMethod(){
            count = 0;
        }
        //静态方法
        public synchronized static void getCounts(){ //属于类级别的锁，对于不同对象不可同时进入同一个类
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println("当前线程名称" + Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        @Override
        public synchronized void run() { //属于方法级别的锁，对于不同对象可同时进入
            getCounts();
        }
    }

测试代码：

    public class StaticMethodTest {
        public static void main(String[] args) {
            StaticMethod sync1 = new StaticMethod();
            StaticMethod sync2 = new StaticMethod();
            Thread thread1 = new Thread(sync1, "thread1");
            Thread thread2 = new Thread(sync2, "thread2");
            thread1.start();
            thread2.start();
        }
    }

结果分析：

　　sync1和sync2是StaticMethod的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法getCounts，而静态方法是属于类的，所以sync1和sync2相当于用了同一把锁。这与非静态方法是不同的。 

1.3修饰一个类

　　说明：对于类锁，有几种方式：（1）synchronized修饰静态方法；（2）synchronized修饰静态变量；（3）synchronized代码块中直接引入类名称。前2种方式，前面已经做了详细的解释，这里主要解释第三种。

代码示例：

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

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

参考资料：

http://www.importnew.com/21866.html

http://www.importnew.com/21907.html

http://www.cnblogs.com/xujian2014/tag/