架构师养成记--3.synchronized细节问题

一、synchronized有锁重入的特点，某个线程得到对象的锁后，再次请求此对象可以再次得到改对象的锁。如下示例，在method1中调用method2，在method2中调用method3，而method1、method2和method3都是加了synchronized关键字的。

 /**
  * synchronized的重入
  * @author alienware
  *
  */
 public class SyncDubbo1 {

     public synchronized void method1(){
         System.out.println("method1..");
         method2();
     }
     public synchronized void method2(){
         System.out.println("method2..");
         method3();
     }
     public synchronized void method3(){
         System.out.println("method3..");
     }

     public static void main(String[] args) {
         final SyncDubbo1 sd = new SyncDubbo1();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 sd.method1();
             }
         });
         t1.start();
     }
 }

二、父类和子类的方法都是synchronized的，在子类的方法中调用父类的方法，也是线程安全的。

 /**
  * synchronized的重入
  * @author alienware
  *
  */
 public class SyncDubbo2 {

     static class Main {
         public int i = 10;
         public synchronized void operationSup(){
             try {
                 i--;
                 System.out.println("Main print i = " + i);
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     static class Sub extends Main {
         public synchronized void operationSub(){
             try {
                 while(i > 0) {
                     i--;
                     System.out.println("Sub print i = " + i);
                     Thread.sleep(100);
                     this.operationSup();
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) {

         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 Sub sub = new Sub();
                 sub.operationSub();
             }
         });

         t1.start();
     }

 }

执行结果：

三、synchronized方法内抛异常怎么处理

　　throw RuntimeException打断此线程或者记录日志然后continue，选择哪种方案取决于具体业务要求。

 /**
  * synchronized异常
  * @author alienware
  *
  */
 public class SyncException {

     private int i = 0;
     public synchronized void operation(){
         while(true){
             try {
                 i++;
                 Thread.sleep(100);
                 System.out.println(Thread.currentThread().getName() + " , i = " + i);
                 if(i == 20){
                     //Integer.parseInt("a");
                     throw new RuntimeException();
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) {

         final SyncException se = new SyncException();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 se.operation();
             }
         },"t1");
         t1.start();
     }

 }

四、synchronized代码块锁，实用起来也会比较灵活

　　this、class、Object都可以用来作为代码块锁

 /**
  * 使用synchronized代码块加锁,比较灵活
  * @author alienware
  *
  */
 public class ObjectLock {

     public void method1(){
         synchronized (this) {    //对象锁
             try {
                 System.out.println("do method1..");
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public void method2(){        //类锁
         synchronized (ObjectLock.class) {
             try {
                 System.out.println("do method2..");
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     private Object lock = new Object();
     public void method3(){        //任何对象锁
         synchronized (lock) {
             try {
                 System.out.println("do method3..");
                 Thread.sleep(2000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) {

         final ObjectLock objLock = new ObjectLock();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 objLock.method1();
             }
         });
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 objLock.method2();
             }
         });
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 objLock.method3();
             }
         });

         t1.start();
         t2.start();
         t3.start();

     }

 }

五、尽量不要用String常量作为锁

如下代码只会有t1线程运行，但可以new一个String对象。

 /**
  * synchronized代码块对字符串的锁，注意String常量池的缓存功能
  * @author alienware
  *
  */
 public class StringLock {

     public void method() {
         //new String("字符串常量")
         synchronized ("字符串常量") {
             try {
                 while(true){
                     System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
                     Thread.sleep(1000);
                     System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

     public static void main(String[] args) {
         final StringLock stringLock = new StringLock();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 stringLock.method();
             }
         },"t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 stringLock.method();
             }
         },"t2");

         t1.start();
         t2.start();
     }
 }

六、一个对象被用作锁时，这个对象内的属性发生变化不会影响锁的使用。

 /**
  * 同一对象属性的修改不会影响锁的情况
  * @author alienware
  *
  */
 public class ModifyLock {

     private String name ;
     private int age ;

     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }

     public synchronized void changeAttributte(String name, int age) {
         try {
             System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 开始");
             this.setName(name);
             this.setAge(age);

             System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 修改对象内容为： "
                     + this.getName() + ", " + this.getAge());

             Thread.sleep(2000);
             System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 结束");
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         final ModifyLock modifyLock = new ModifyLock();
         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 modifyLock.changeAttributte("张三", 20);
             }
         },"t1");
         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 modifyLock.changeAttributte("李四", 21);
             }
         },"t2");

         t1.start();
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         t2.start();
     }

 }