并发编程（三）—— synchronized

一、synchronized锁重入

1. 概念

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到了一个对象的锁后，再次请求此对象时是可以再次得到此对象的锁。

2. 示例

【com.xxy.base.sync005.SyncDubbo1】

package com.xxy.base.sync005;

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();
    }
}

【com.xxy.base.sync005.SyncDubbo2】

package com.xxy.base.sync005;

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) {
                // TODO Auto-generated catch block
                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) {
                // TODO Auto-generated catch block
                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();
    }
}

3. 出现异常，锁自动释放，示例：【com.xxy.base.sync005.SyncException】

package com.xxy.base.sync005;

public class SyncException {
    
    private int i = 0;
    public synchronized void operation() {
        while(true) {
            try {
                i++;
                Thread.sleep(200);
                System.out.println(Thread.currentThread().getName() + ", i = " + i);
                if(i == 10) {
                    Integer.parseInt("a");//throw RuntimeException(NumberFormatException)
                }
            } catch (Exception e) {//InterruptedException
                e.printStackTrace();
                System.out.println("log info i = " + i);
                //throw new RuntimeException();
                //continue;
            } 
        }
    }
    
    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();
    }
}

4. 说明

对于web应用程序，异常释放锁的情况，如果不及时处理，很可能对你的应用程序业务逻辑产生严重的错误，比如你现在执行一个队列任务，很多对象都去在等待第一个对象正确执行完毕再去释放锁，但是第一个对象由于异常的出现，导致业务逻辑没有正常执行完毕，就释放了锁，那么可想而知后续的对象执行的都是错误的逻辑。所以，这一点一定要引起注意，在编写代码的时候一定要考虑周全。

二、synchronized代码块

1. 介绍

使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同步的方法执行一个很长时间的任务，那么B线程就必须等待比较长的时间才能执行，这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁粒度。

示例：【com.xxy.base.sync006 Optimize】

2. synchronized可以使用任意的Object进行加锁，用法比较灵活。

示例：【com.xxy.base.sync006 ObjectLock】

3.另外特别注意一个问题，就是不要使用String的常量加锁，会出现死循环问题

示例：【com.xxy.base.sync006 StringLock】

4.锁对象的改变问题，当使用一个对象进行加锁的时候，要注意对象本身发生改变的时候，那么持有的锁就不同。如果对象本身不发生改变，那么依然是同步的，即使是对象的属性发生了改变。

示例：【com.xxy.base.sync006 ChangeLock ModifyLock】

5.死锁问题

示例：【com.xxy.base.sync006 DeadLock】