Java 线程的同步（synchronized）与死锁

同步的引入

当多个线程并发执行时，线程对数据的访问也是并发执行的，假设有线程A和线程B两个线程，同时会访问数据Data，并且更改数据Data。有可能出现一下两种运行顺序：

1. 线程A访问Data–>线程A更改Data–>线程B访问Data–>线程B更改Data
2. 线程A访问Data–>线程B访问Data–>线程A更改Data–>线程B更改Data

情况1运行后，数据正常访问，结果正确；但是如果情况2发生，那么就会出现对同一数值实现两次更改的情况，数据A对Data的更改会失效。
此时产生的问题就是线程不同步引起的。

范例程序：卖票问题

//六个票贩子同时进行售票活动class MyThread implements Runnable {    private int ticket = 10 ;    @Override    public void run() {             for (int x = 0 ; x < 20 ; x++ ) {            if (this.ticket > 0) {                System.out.println( Thread.currentThread().getName() + ": ticket = " + ticket-- ) ;            }        }    }}public class Demo {    public static void main(String args[]) throws Exception{        MyThread mt = new MyThread() ;        new Thread(mt,"票贩子A:").start() ;        new Thread(mt,"票贩子B:").start() ;        new Thread(mt,"票贩子C:").start() ;        new Thread(mt,"票贩子D:").start() ;        new Thread(mt,"票贩子E:").start() ;        new Thread(mt,"票贩子F:").start() ;    }}

输出结果：
票贩子A:: ticket = 9
票贩子A:: ticket = 4
票贩子A:: ticket = 3
票贩子A:: ticket = 2
票贩子A:: ticket = 1
票贩子F:: ticket = 5
票贩子E:: ticket = 6
票贩子D:: ticket = 7
票贩子B:: ticket = 8
票贩子C:: ticket = 10；

如果在售票线程中使用延时：

class MyThread implements Runnable {    private int ticket = 10 ;    @Override    public void run() {             for (int x = 0 ; x < 20 ; x++ ) {            if (this.ticket > 0) {            /****************加入延时，需要用try catch捕获异常**********************/                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            /******************************************/                System.out.println( Thread.currentThread().getName() + ": ticket = " + ticket-- ) ;            }        }    }}public class Demo {    public static void main(String args[]) throws Exception{        MyThread mt = new MyThread() ;        new Thread(mt,"票贩子A:").start() ;        new Thread(mt,"票贩子B:").start() ;        new Thread(mt,"票贩子C:").start() ;        new Thread(mt,"票贩子D:").start() ;        new Thread(mt,"票贩子E:").start() ;        new Thread(mt,"票贩子F:").start() ;    }}

输出结果：
票贩子B:: ticket = 9
票贩子F:: ticket = 5
票贩子E:: ticket = 6
票贩子A:: ticket = 10
票贩子D:: ticket = 7
票贩子C:: ticket = 8
票贩子E:: ticket = 4
票贩子F:: ticket = 1
票贩子D:: ticket = -1
票贩子B:: ticket = 2
票贩子A:: ticket = 3
票贩子C:: ticket = 0
票贩子E:: ticket = -2

因为存在休眠，所以会出现错误，最后票数出现负数。解决方法：上锁。可以采用两种方法完成：同步代码块，同步方法。

synchronized关键字

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
2. 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
3. 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
4. 第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
5. 以上规则对其它对象锁同样适用。

使用同步代码块

同步代码块使用synchronized关键字定义的代码块，但是在同步的时候一定要设置好一个同步对象，一般使用当前对象this表示。

class MyThread implements Runnable {    private int ticket = 10 ;    @Override    public void run() {             for (int x = 0 ; x < 20 ; x++ ) {        /**************同步代码块****************/            synchronized(this) {            if (this.ticket > 0) {                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                System.out.println( Thread.currentThread().getName() + ": ticket = " + ticket-- ) ;                }            }        /******************************************/        }    }}public class Demo {    public static void main(String args[]) throws Exception{        MyThread mt = new MyThread() ;        new Thread(mt,"票贩子A:").start() ;        new Thread(mt,"票贩子B:").start() ;        new Thread(mt,"票贩子C:").start() ;        new Thread(mt,"票贩子D:").start() ;        new Thread(mt,"票贩子E:").start() ;        new Thread(mt,"票贩子F:").start() ;    }}

此时程序明显感觉慢了，因为需要一个个排队进入执行。虽然性能变差了，但是数据的安全性提高了，也就是说异步处理（不加synchronize）和同步处理的区别也在于此。

2.使用同步方法（使用synchronized修饰的方法）

class MyThread implements Runnable {    private int ticket = 10 ;    @Override    public void run() {             for (int x = 0 ; x < 20 ; x++ ) {            this.sale() ;        }    }    /*************同步方法************************/    public synchronized void sale() {            if (this.ticket > 0) {                try {                    Thread.sleep(100);                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                System.out.println( Thread.currentThread().getName() + ": ticket = " + ticket-- ) ;                }    /******************************************/    }public class Demo {    public static void main(String args[]) throws Exception{        MyThread mt = new MyThread() ;        new Thread(mt,"票贩子A:").start() ;        new Thread(mt,"票贩子B:").start() ;        new Thread(mt,"票贩子C:").start() ;        new Thread(mt,"票贩子D:").start() ;        new Thread(mt,"票贩子E:").start() ;        new Thread(mt,"票贩子F:").start() ;        }}

结论：多个线程访问同一资源的时候一定要考虑到线程的同步，但是同步会影响程序的性能，同时会提升数据的安全性，过多的同步（synchronized）会有可能出现死锁。

死锁

创建两个字符串a和b，再创建两个线程A和B，让每个线程都用synchronized锁住字符串（A先锁a，再去锁b；B先锁b，再锁a），如果A锁住a，B锁住b，A就没办法锁住b，B也没办法锁住a，这时就陷入了死锁。

public class DeadLock {    public static String obj1 = "obj1";    public static String obj2 = "obj2";    public static void main(String[] args){        Thread a = new Thread(new Lock1());        Thread b = new Thread(new Lock2());        a.start();        b.start();    }    }class Lock1 implements Runnable{    @Override    public void run(){        try{            System.out.println("Lock1 running");            while(true){                synchronized(DeadLock.obj1){                    System.out.println("Lock1 lock obj1");                    Thread.sleep(3000);//获取obj1后先等一会儿，让Lock2有足够的时间锁住obj2                    synchronized(DeadLock.obj2){                        System.out.println("Lock1 lock obj2");                    }                }            }        }catch(Exception e){            e.printStackTrace();        }    }}class Lock2 implements Runnable{    @Override    public void run(){        try{            System.out.println("Lock2 running");            while(true){                synchronized(DeadLock.obj2){                    System.out.println("Lock2 lock obj2");                    Thread.sleep(3000);                    synchronized(DeadLock.obj1){                        System.out.println("Lock2 lock obj1");                    }                }            }        }catch(Exception e){            e.printStackTrace();        }    }}

可以看到，Lock1获取obj1，Lock2获取obj2，但是它们都没有办法再获取另外一个obj，因为它们都在等待对方先释放锁，这时就是死锁。