synchronized的补充

因为之前对synchronized不是很了解，所以前面就照搬尚学堂的课程，这里经过一些学习，稍微有点理解了这个synchronized关键字的用法。下面就说一些synchronized注意事项：

• 当对某个对象进行锁定的时候

/**
 * 银行账户类
 */
class Account {
   String name;
   float amount;

   public Account(String name, float amount) {
      this.name = name;
      this.amount = amount;
   }
   //存钱
   public  void deposit(float amt) {
      amount += amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
   //取钱
   public  void withdraw(float amt) {
      amount -= amt;
      try {
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }

   public float getBalance() {
      return amount;
   }
}

/**
 * 账户操作类
 */
class AccountOperator implements Runnable{
   private Account account;
   public AccountOperator(Account account) {
      this.account = account;
   }

   public void run() {
      synchronized (account) {
         account.deposit(500);
         account.withdraw(500);
         System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
      }
   }

  public static void main(String[] args){
        Account account = new Account("zhang san", 10000.0f);
        AccountOperator accountOperator = new AccountOperator(account);

        final int THREAD_NUM = 5;
        Thread threads[] = new Thread[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i ++) {
           threads[i] = new Thread(accountOperator, "Thread" + i);
           threads[i].start();
}
  }
}

输出结果：Thread3:10000.0 
        Thread2:10000.0 
        Thread1:10000.0 
        Thread4:10000.0 
        Thread0:10000.0

在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。

• 当锁定的是静态类或者静态方法

看内存图，对于静态static类和方法是存放在方法去中的，和new出来的类调用方式是不一样的，所以对于static变量和方法其实无论怎么创建，调用的都是同一个地址，静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

/**
 - 同步线程
 */
class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public synchronized static void method() {
      for (int i = 0; i < 5; i ++) {
         try {
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public synchronized void run() {
      method();
   }
   public static void main(String[] args){
        Account account = new Account("zhang san", 10000.0f);
        AccountOperator accountOperator = new AccountOperator(account);

        final int THREAD_NUM = 5;
        Thread threads[] = new Thread[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i ++) {
           threads[i] = new Thread(accountOperator, "Thread" + i);
           threads[i].start();
}
  }
}

输出结果：
        SyncThread1:0 
        SyncThread1:1 
        SyncThread1:2 
        SyncThread1:3 
        SyncThread1:4 
        SyncThread2:5 
        SyncThread2:6 
        SyncThread2:7 
        SyncThread2:8 
        SyncThread2:9

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

一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

public class TT implements Runnable{

    private int b = 100;

    public synchronized void m1(){
        b = 1000;
        try {
            Thread.sleep(1000);
            System.out.println("b="+b);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    public void m2(){
        System.out.println(b);
    }

    @Override
    public void run() {
        m1();
    }

    public static void main(String[] args){
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();  //在这个线程启动之后，会睡眠3秒钟
        try {
            Thread.sleep(500); // 这个睡眠时间是让main线程休眠一会，要保证TT线程已经启动，已经执行到方法里面了
            tt.m2();  //上面线程是启动锁定的线程，然而这个时候main线程还是可以启动。线程已经锁定了，b=1000了，main线程仍然在运行，而且输出
                      //为1000,所以线程虽然可以锁定，但是m2()方法没有锁定，仍然可以访问，所以main线程里面输出的不是100而是1000。
                      //说明一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：
        1000
        b=1000

下面是另外一个实例：

public class CpoyTT implements Runnable{

    private int b = 100;

    public synchronized void m1(){
        b = 1000;
        try {
            Thread.sleep(2000);
            System.out.println("b="+b);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    public void m2(){
        try {
            Thread.sleep(1000);
            b = 2000;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        m1();
    }

    public static void main(String[] args){
        CpoyTT tt = new CpoyTT();
        Thread t = new Thread(tt);
        t.start();  //在这个线程启动之后，会睡眠3秒钟

        tt.m2();  //同TT，main线程还是可以访问没有被锁定的方法，如果m2()中的睡眠时间少于m1()中的话，会改变b的值

    }
}

输出结果：b=2000

• 在用synchronized修饰方法时要注意以下几点：

synchronized关键字不能继承： 虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
在子类方法中加上synchronized关键字

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

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

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

1. 在定义接口方法时不能使用synchronized关键字。
2. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

参考博客