Java---多线程之死锁

package thread.deadLock.lock1;
/**
 * 简单的类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S {
    public int a = 0 ;
}

package thread.deadLock.lock1;
/**
 * 含有main方法的类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class DeadLock1 {
    public static void main(String[] args) {
        S s = new S();
        Thread b = new Thread(new ThreadB(s));
        Thread a = new Thread(new ThreadA(s,b));
        a.start();
        b.start();
    }


}

package thread.deadLock.lock1;
/**
 * ThreadB类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadB implements Runnable{
    private S s = null;


    public ThreadB(S s) {
        this.s = s;
    }


    @Override
    public  void run() {
        System.out.println("线程B在等待锁s！");
        synchronized (s) {
            System.out.println("线程B拿到锁s！");
            s.a=100;
            System.out.println("线程B  s.a = " + s.a);
        }
    }

}

package thread.deadLock.lock1;
/**
 * ThreadA类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadA implements Runnable{
    private S s = null;
    private Thread b = null;

    public ThreadA(S s,Thread b) {
        this.b = b;
        this.s = s;
    }


    @Override
    public  void run() {
        System.out.println("线程A在等待锁s！");
        synchronized (s) {
            System.out.println("线程A拿到锁s！");
            try {
                //调用b线程的运行代码。
                //但是此时的锁在a线程手里，b拿不到锁。
                //所以出现了，b等待a给锁，a就拿着锁等待b运行，所以出现了死锁！
                b.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s.a = " + s.a);
        }
    }

}

package thread.deadLock.lock2;
/**
 * 资源类1
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S1 {
    public int a =0;
}

package thread.deadLock.lock2;
/**
 * 资源类2
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class S2 {
    public int a =1;
}

package thread.deadLock.lock2;
/**
 * 
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class DeadLock2 {

    public static void main(String[] args) {
        //如果要解决这种多资源出现的死锁，可以把多个资源打包成一个综合资源，
        //把综合资源变成一个对象锁,哪个线程一拿到锁就有全部资源了
        //在设计阶段就应该考虑到----把多线程中的每个线程所用的互斥资源图画出来
        //--从图中看出哪些线程存在共享互斥资源，然后分析是否可能存在死锁
        //这个死锁存在随机性！！！

        S1 s1 = new S1();
        S2 s2 = new S2();

        Thread a = new Thread(new ThreadA(s1,s2));
        Thread b = new Thread(new ThreadB(s1,s2));

        a.start();
        b.start();

    }

}

package thread.deadLock.lock2;
/**
 * ThreadA---a线程运行代码类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadA implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;


    public ThreadA(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }


    @Override
    public void run() {
        System.out.println("线程a在等待锁s1!");
        synchronized (s1) {//拿到了锁s1
            System.out.println("s1.a=" + s1.a);
            System.out.println("线程a拿到了锁s1");
            System.out.println("线程a在等待锁s2");
            synchronized (s2) {//拿到锁s2
                System.out.println("线程a拿到了锁s2");
                System.out.println("s2.a=" + s2.a);
            }//释放锁s2
            System.out.println("线程a释放了锁s2");
        }//释放锁s1


    }

}

package thread.deadLock.lock2;
/**
 * ThreadB---b线程运行代码类
 * @author 陈浩翔
 *
 * 2016-4-22
 */
public class ThreadB implements Runnable{
    private S1 s1 = null;
    private S2 s2 = null;



    public ThreadB(S1 s1, S2 s2) {
        this.s1 = s1;
        this.s2 = s2;
    }



    @Override
    public void run() {
        System.out.println("线程b在等待锁s2!");
        synchronized (s2) {//拿到了锁s2
            System.out.println("s2.a=" + s2.a);
            System.out.println("线程b拿到了锁s2");
            System.out.println("线程b在等待锁s1");
            synchronized (s1) {//拿到锁s1
                System.out.println("线程b拿到了锁s1");
                System.out.println("s1.a=" + s1.a);
            }//释放锁s1
            System.out.println("线程b释放了锁s1");
        }//释放锁s2


    }

}