对象及变量的并发访问-----synchronized同步（7）----- 内置类同步问题

创建一个类，里面两个内置类，第一个内置类里面两个方法，一个方法用第二个内置类实例作监视对象，一个直接synchronized修饰；

第二个内置类里面直接synchronized修饰的方法。

package service;

/**
 * Created by zhc on 2017/10/11
 */
public class OutClass {
    public static class InnerClass1{
        public void method1(InnerClass2 innerClass2){
            synchronized (innerClass2){
                System.out.println(Thread.currentThread().getName()+"现在进入innerClass1的method1");
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+" "+i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()+"现在离开了innerClass1的method2");
            }
        }

        synchronized public void method2(){
            System.out.println(Thread.currentThread().getName()+"现在进入innerClass1的method2");
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"现在离开了innerClass1的method2");
        }
    }
    public static class InnerClass2{
        synchronized public void method(){
            System.out.println(Thread.currentThread().getName()+"现在进入innerClass2的method");
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
            }
            System.out.println(Thread.currentThread().getName()+"现在离开了innerClass的method");
        }
    }
}

run：

package test;

import service.OutClass;
/**
 * Created by zhc on 2017/10/11
 */
public class Run7 {
    public static void main(String[] args) {

        final OutClass.InnerClass1 class1 = new OutClass.InnerClass1();
        final OutClass.InnerClass2 class2 = new OutClass.InnerClass2();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                class1.method1(class2);
            }
        },"T1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                class1.method2();
            }
        },"T2");

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                class2.method();
            }
        },"T3");

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

结果：

T2现在进入innerClass1的method2
T1现在进入innerClass1的method1
T2 0
T1 0
T1 1
T2 1
T1 2
T1 3
T2 2
T1 4
T1现在离开了innerClass1的method2
T3现在进入innerClass2的method
T3 0
T3 1
T3 2
T3 3
T3 4
T3现在离开了innerClass的method
T2 3
T2 4
T2现在离开了innerClass1的method2

总结：

T1的对象监视器是InnerClass的实例，那么class2作为对象监视器，那么class2中的synchronized的方法也是本身实例的所。T2则是与T1、T3无关的锁，一直异步执行。