synchronized同步锁

synchronized简介

synchronized是Java中的关键字，是一种同步锁。它可以修饰以下对象
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

synchronized使用注意事项

1.多个对象就有多个同步锁

synchronized获取的都是对象锁，而不是把一段代码和方法当成锁。看看下面的例子

class MyObject{
     private String passWord = "a";
     private String userName = "b";
     synchronized public void setValue(String p, String u){ 
       this.passWord = p;
        try{
            Thread.sleep(100);
        }catch(InterruptedException e){
       }
       this.userName = u;
       System.out.println(Thread.currentThread().getName() + " passWord :" + passWord);
       System.out.println(Thread.currentThread().getName() + " userName :" + userName);
    }
}

public class Thread_test {
    public static void main (String[] args){      
        MyObject obj1 = new MyObject();
        MyObject obj2 = new MyObject();

        Thread thread1 = new Thread(){
            @Override
            public void run(){
                System.out.println("线程1 开始运行");
            obj1.setValue("aa","bb");
            }
        };          
        Thread thread2 = new Thread(){
            @Override
            public void run(){
                System.out.println("线程2 开始运行");
                obj2.setValue("cc","dd");
            }
        };
        thread1.setName("线程1");
        thread1.start();
        thread2.setName("线程2");
        thread2.start()；
   }
}

在上面的例子中实例化了2个MyObject对象obj1和obj2，然后别在线程1和2用调用obj1和obj2的方法setValue，可以看到程序的执行顺序和结果，他们没有受synchronized的影响，各自在自己空间运行。

2.如果线程A持有 object 对象的synchronized同步锁，这时如果线程B要调用object对象中具有synchronized修饰的方法，则需要等待线程A释放后才能执行(不管线程A和B调用的是否是同一个方法，只要是被synchronized 修饰，线程B都必须等待)。实例如下：

class MyObject{

     private String passWord = "a";
     private String userName = "b";

     synchronized public void setPassWord(String p){
         this.passWord = p;
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){

           }
           System.out.println(Thread.currentThread().getName() + " 执行完成 " + " passWord :" + passWord);
     }

     synchronized public void  setUserName(String u){
        this.userName = u;
       System.out.println(Thread.currentThread().getName() +  " 执行完成 " + "  userName :" + userName);
     }
}

public class Thread_test {
      public static void main (String[] args)｛
              MyObject obj1 = new MyObject();  
              Thread thread1 = new Thread(){
                  @Override
                  public void run(){
                  System.out.println("线程1 开始运行");
                  obj1.setPassWord("aa");
                  }
              };          
              Thread thread2 = new Thread(){
                  @Override
                  public void run(){
                      System.out.println("线程2 开始运行");
                      obj1.setUserName("dd");
                  }
              };

              thread1.setName("线程1");
              thread1.start();

              thread2.setName("线程2");
              thread2.start();
        ｝
｝

可以看到在上面的例子中线程1先执行，紧接着线程2执行。但在线程1执行的方法setPassWord中休眠1秒，由于线程1获取同步锁，所以线程2要等到线程1释放了锁后，线程2才能调用setUserName函数。虽然线程1没有调用方法setUserName，但是setUserName是被synchronized修饰，所以仍然要同步。如果我们将函数setUserName前面的synchronized去掉看看执行的结果又是啥

我们看到线程2先执行完全。这说明线程A持有 object 对象的synchronized同步锁，这时如果线程B可以调用object对象中具有非synchronized修饰的方法，而不需等待线程A释放同步锁。

3.synchronized同步锁不能继承

class MyObject{
     private String passWord = "a";
     private String userName = "b";

     synchronized public void setValue(String p, String u){
             System.out.println("线程 " + Thread.currentThread().getName() +  "父类  MyObject" + " setValue 开始运行"); 
             this.passWord = p;
             this.userName = u;
             System.out.println("线程 " + Thread.currentThread().getName() + "父类  MyObject" + " passWord :" + passWord);
             System.out.println("线程 " + Thread.currentThread().getName() + "父类  MyObject" + " userName :" + userName);
        try{
            Thread.sleep(2000);
        }catch(InterruptedException e){

       }
      System.out.println("线程 " + Thread.currentThread().getName() + "父类  MyObject" + " setValue 运行结束");
    }
}

class MyObject1 extends MyObject{

     private String passWord = "a";
     private String userName = "b";

     public void setValue(String p, String u){
          System.out.println("线程 " + Thread.currentThread().getName() +  "子类  MyObject" + " setValue 开始运行");
          this.passWord = p;
          this.userName = u;

         System.out.println("线程 " + Thread.currentThread().getName() + "子类  MyObject1" + " passWord :" + passWord);
         System.out.println("线程 " + Thread.currentThread().getName() + "子类  MyObject1" + " userName :" + userName);
         super.setValue(p, u);
         System.out.println("线程 " + Thread.currentThread().getName() +  "子类  MyObject" + " setValue 运行结束");
    }
}

public class Thread_test {
    public static void main (String[] args){
        try{         
            MyObject1 obj1 = new MyObject1();
            Thread thread1 = new Thread(){
                @Override
                public void run(){
                obj1.setValue("11","22");
            }

         };
         thread1.setName("a");
         thread1.start();

             Thread.sleep(10);

         Thread thread2 = new Thread(){
             @Override
             public void run(){
                 obj1.setValue("33", "44");
             }
          };
         thread2.setName("b");
         thread2.start(); 
         }catch(InterruptedException e){
         }    
     }
}

上面的例子MyObject1继承于MyObject并重写了函数setValue，MyObject1的函数setValue没有添加同步锁，MyObject的的函数setValue添加了同步锁，我们还在MyObject1的函数setValue里面调用了父类的setValue函数。看看上面两个线程的执行结果， MyObject1的函数setValue没有添加同步锁，所以线程1，2可以各自执行，同时运行(不用等到线程1执行完成，线程2才开始执行)，但是由于MyObject的的函数setValue添加了同步锁，所以MyObject1在调用父类的setValue函数时必须同步，也就是线程1运行完成了，线程2才能开始运行。

4.synchronized修饰代码块之间的同步问题

A.synchronized(this)
当一个线程访问object的一个synchronized(this)的同步代码块时，其他线程对同一个object中所有其他synchronized(this)同步代码快将 被阻塞。
B. .synchronized(非this对象 x)
当一个线程访问object的一个synchronized(X)的同步代码块时，其他线程对同一个object中所有其他synchronized(X)同步代码快将 被阻塞。但是synchronized(y)，synchronized(z)修饰的代码块不会被阻塞

5.synchronized修饰静态函数

A. 与修饰非静态方法的区别
synchronized关键字添加到static方法上是给Class类添加锁，而synchronized添加到非static方法上是给对象加锁
B.synchronized静态函数同步情况
当一个线程访问synchronized静态函数，其他线程可以对该类的其他synchronized静态函数访问，而不会被阻塞。

6.synchronized(object.class)修饰代码块

当一个线程访问synchronized(object.class)代码块时，其他任何线程访问该代码块时都会被阻塞。