Java多线程问题--内置类和静态内置类的应用

本文内容大部分引自《Java多线程编程核心技术》，感谢作者！！！

代码地址：https://github.com/xianzhixianzhixian/thread.git

书中前几章的自然看得懂为什么结果是这样，没看的也可以看看本文的分析，希望能够有所帮助

第一个示例

第一个示例中是内置静态类的中的两个方法使用不同的对象锁，结果可想而知，两个方法是异步运行的。

OutClass.java

package thread.synchronize.innerclass;

/**
 * 内置静态类使用不同的对象锁异步第一种情况
 * @author: xianzhixianzhixian
 * @date: 2018-12-24 20:01
 */
public class OutClass {
    static class Inner{
        public void method1(){
            synchronized ("其它锁"){
                for (int i = 0; i <= 10; i++) {
                    System.out.println(Thread.currentThread().getName()+" i="+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        public synchronized void method2(){
            for (int i = 11; i <= 20; i++) {
                System.out.println(Thread.currentThread().getName()+" i="+i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Run.java

package thread.synchronize.innerclass;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-24 20:05
 */
public class Run {
    public static void main(String[] args) {
        final OutClass.Inner inner = new OutClass.Inner();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                inner.method1();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                inner.method2();
            }
        });
        t1.start();
        t2.start();
    }
}

运行结果：

第二个示例

第二个示例中，有两个内置静态类。第一个静态类中，method0使用的是第二个静态类的实例的对象锁，method1使用的是synchronized方法，和synchronized(this)相同，使用的是第一个静态类实例的对象锁。第二个内置类中，method0使用的是synchronized方法，和synchronized(this)相同，使用的是第二个静态类实例的对象锁；结果可想而知，两个method0方法同步运行，method1和两个method0方法异步运行。

OutClass0.java

package thread.synchronize.innerclass;

/**
 * 内置静态类使用不同的对象锁异步第二种情况，内置静态类使用相同对象锁同步的情况
 * @author: xianzhixianzhixian
 * @date: 2018-12-24 20:08
 */
public class OutClass0 {
    static class InnerClass0{
        public void method0(InnerClass1 class1){
            String threadName = Thread.currentThread().getName();
            synchronized (class1){
                System.out.println(threadName+" 进入InnserClass0类中的method0方法");
                for (int i = 0; i < 10; i++) {
                    System.out.println("i="+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(threadName+" 离开InnserClass0类中的method0方法");
            }
        }

        public synchronized void method1(){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+" 进入InnserClass0类中的method1方法");
            for (int j = 0; j < 10; j++) {
                System.out.println("j="+j);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(threadName+" 离开InnserClass0类中的method1方法");
        }
    }

    static class InnerClass1{
        public synchronized void method0(){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName+" 进入InnserClass1类中的method0方法");
            for (int k = 0; k < 10; k++) {
                System.out.println("k="+k);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(threadName+" 离开InnserClass0类中的method0方法");
        }
    }
}

Run.java

package thread.synchronize.innerclass;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-24 20:18
 */
public class Run1 {

    public static void main(String[] args) {
        final OutClass0.InnerClass0 in0 = new OutClass0.InnerClass0();
        final OutClass0.InnerClass1 in1 = new OutClass0.InnerClass1();
        Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                in0.method0(in1);
            }
        }, "T1");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                in0.method1();
            }
        }, "T2");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                in1.method0();
            }
        }, "T3");
        t0.start();
        t1.start();
        t2.start();
    }
}

运行结果：