【嵌牛导读】：JAVA多线程中的锁问题是很经典的问题，也比较复杂。今天给大家分享一下我对内部类的锁问题的分析，主要是锁对象分别是内部类，内部类的方法，静态内部类的区别。

【嵌牛鼻子】：java多线程   内部类  静态内部类

【嵌牛提问】：内部类的锁问题

【嵌牛正文】：

一、关于对象锁和类锁

大家首先要知道对象锁和类锁的区别。

对象锁：如果synchronized关键字作用与非静态的方法和代码块上时，这时候同步锁锁的是对象，即会阻塞试图访问该对象同步方法的线程，但不会阻塞试图访问该类其他对象同步方法的线程，也不会阻塞试图访问该类的静态方法的线程。

类锁：如果synchronized关键字作用于静态方法上，这时候同步锁锁的是类，即会阻塞试图访问该类的静态同步方法的线程。

二、内部类

大家知道内部类有成员内部类，局部内部类，匿名内部类和静态内部类。

成员内部类对象的创建需要一个父类的对象。

局部内部类只在方法体以内，不属于外部类。

匿名内部类似乎不涉及多线程锁的问题（我暂时也不清楚）

静态内部类对象的创建不需要父类的对象

三、内部类的对象锁和类锁

内部类的锁问题和外部类的锁问题相类似。

我总结为一下三点：

当锁的是非静态的内置类对象时，只会阻塞访问同一个内置类对象（同一个外置类对象创建的同一个内置类）方法的线程。

当锁的是内置类的方法时，会阻塞访问同一个内置类对象的其他同步方法的线程。

当锁的是静态内置类时，锁的是这个内置类（静态内置类的创建不依赖于外部类对象），会阻塞所有访问该静态内置类的线程

下面使用程序来验证：

1.

public class OutClass {

    public class InnerClass1{

        public void method1(InnerClass2 class2){

            String threadName=Thread.currentThread().getName();

            synchronized (class2){

                System.out.println(threadName+"进入InnerClass1中的method1方法");

                for(int i=0;i<10;i++){

                    System.out.println("InnerClass1中的method1方法i="+i);

                    try{

                        Thread.sleep(100);

                    }catch (InterruptedException e){

                        e.printStackTrace();

                    }

}

                System.out.println(threadName+"离开InnerClass1中的method1方法");

            }

}

        public synchronized void method2(){

            String threadName=Thread.currentThread().getName();

            System.out.println(threadName+"进入InnerClass1中的method2方法");

            for(int i=0;i<10;i++){

                System.out.println("InnerClass1中的method2方法i="+i);

                try{

                    Thread.sleep(100);

                }catch (InterruptedException e){

                    e.printStackTrace();

                }

}

            System.out.println(threadName+"离开InnerClass1中的method2方法");

        }

}

    public class InnerClass2{

        public synchronized void method1(){

            String threadName=Thread.currentThread().getName();

            System.out.println(threadName+"进入InnerClass2中的method1方法");

            for(int k=0;k<10;k++){

                System.out.println("InnerClass2中的method1方法k="+k);

                try{

                    Thread.sleep(100);

                }catch (InterruptedException e){

                    e.printStackTrace();

                }

}

            System.out.println(threadName+"离开InnerClass2中的method1方法");

        }

}

}

程序分析：首先在一个OutClass类，在该类中定义两个内部类InnerClass1和InnerClass2

内部类InnerClass1中有两个同步方法，一个锁的是InnerClass2的对象，一个锁的是InnerClass1对象

内部类InnerClass2中有一个同步方法，锁的是父类InnerClass2对象

在Run中执行线程操作

public class Run {

    public static void main(String[] args){

        OutClass outClass=new OutClass();

        OutClass.InnerClass1 in1=outClass.new InnerClass1();

        OutClass.InnerClass2 in2=outClass.new InnerClass2();

        Thread t1=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method1(in2);

            }

        },"T1");

        Thread t2=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method2();

            }

        },"T2");

        Thread t3=new Thread(new Runnable() {

            @Override

            public void run() {

                in2.method1();

            }

        },"T3");

        t1.start();

        t2.start();

        t3.start();

    }

}

在main方法中首先创建一个外部类对象，然后使用该外部类对象创建两个内部类对象。

然后创建三个线程，分别执行InnerClass1中的method1，InnerClass1中的method2,InnerClass2中的method1。

结果如下

T1进入InnerClass1中的method1方法

T2进入InnerClass1中的method2方法

InnerClass1中的method1方法i=0

InnerClass1中的method2方法i=0

InnerClass1中的method2方法i=1

InnerClass1中的method1方法i=1

InnerClass1中的method1方法i=2

InnerClass1中的method2方法i=2

InnerClass1中的method1方法i=3

InnerClass1中的method2方法i=3

InnerClass1中的method1方法i=4

InnerClass1中的method2方法i=4

InnerClass1中的method2方法i=5

InnerClass1中的method1方法i=5

InnerClass1中的method1方法i=6

InnerClass1中的method2方法i=6

InnerClass1中的method2方法i=7

InnerClass1中的method1方法i=7

InnerClass1中的method1方法i=8

InnerClass1中的method2方法i=8

InnerClass1中的method1方法i=9

InnerClass1中的method2方法i=9

T1离开InnerClass1中的method1方法

T2离开InnerClass1中的method2方法

T3进入InnerClass2中的method1方法

InnerClass2中的method1方法k=0

InnerClass2中的method1方法k=1

InnerClass2中的method1方法k=2

InnerClass2中的method1方法k=3

InnerClass2中的method1方法k=4

InnerClass2中的method1方法k=5

InnerClass2中的method1方法k=6

InnerClass2中的method1方法k=7

InnerClass2中的method1方法k=8

InnerClass2中的method1方法k=9

T3离开InnerClass2中的method1方法

结果分析:首先，两个内部类对象都是同一个外部类对象创建的，所以两个内部类对象是会出现同步问题的。

然后Innerclass1的method1锁的对象和Innerclass2的method1锁的对象一样，所以两个T1和T3会顺序执行，T1和T2同步执行。

那么，如果我们使用两个不同的外部类对象来创建两个内部类的话，是不是三个线程都会顺序执行了呢？

修改Run为：

public class Run {

    public static void main(String[] args){

        OutClass outClass=new OutClass();

        OutClass outClass1=new OutClass();

        OutClass.InnerClass1 in1=outClass.new InnerClass1();

        OutClass.InnerClass2 in2=outClass.new InnerClass2();

        OutClass.InnerClass2 in3=outClass1.new InnerClass2();

        Thread t1=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method1(in2);

            }

        },"T1");

        Thread t2=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method2();

            }

        },"T2");

        Thread t3=new Thread(new Runnable() {

            @Override

            public void run() {

                in3.method1();

            }

        },"T3");

        t1.start();

        t2.start();

        t3.start();

    }

}

结果：

T2进入InnerClass1中的method2方法

InnerClass1中的method2方法i=0

T1进入InnerClass1中的method1方法

T3进入InnerClass2中的method1方法

InnerClass1中的method1方法i=0

InnerClass2中的method1方法k=0

InnerClass1中的method2方法i=1

InnerClass1中的method1方法i=1

InnerClass2中的method1方法k=1

InnerClass2中的method1方法k=2

InnerClass1中的method1方法i=2

InnerClass1中的method2方法i=2

InnerClass2中的method1方法k=3

InnerClass1中的method1方法i=3

InnerClass1中的method2方法i=3

InnerClass1中的method2方法i=4

InnerClass2中的method1方法k=4

InnerClass1中的method1方法i=4

InnerClass2中的method1方法k=5

InnerClass1中的method1方法i=5

InnerClass1中的method2方法i=5

InnerClass1中的method2方法i=6

InnerClass2中的method1方法k=6

InnerClass1中的method1方法i=6

InnerClass2中的method1方法k=7

InnerClass1中的method1方法i=7

InnerClass1中的method2方法i=7

InnerClass1中的method2方法i=8

InnerClass2中的method1方法k=8

InnerClass1中的method1方法i=8

InnerClass2中的method1方法k=9

InnerClass1中的method2方法i=9

InnerClass1中的method1方法i=9

T1离开InnerClass1中的method1方法

T2离开InnerClass1中的method2方法

T3离开InnerClass2中的method1方法

结果分析：因为三个线程相互不持有对方的锁，所以三个线程同时执行

2.

修改程序

public class OutClass {

    static  public class InnerClass1{

        public  synchronized void method1(){

            String threadName=Thread.currentThread().getName();

                System.out.println(threadName+"进入InnerClass1中的method1方法");

                for(int i=0;i<10;i++){

                    System.out.println("InnerClass1中的method1方法i="+i);

                    try{

                        Thread.sleep(100);

                    }catch (InterruptedException e){

                        e.printStackTrace();

                    }

}

                System.out.println(threadName+"离开InnerClass1中的method1方法");

            }

        public static synchronized void method2(){

            String threadName=Thread.currentThread().getName();

            System.out.println(threadName+"进入InnerClass1中的method2方法");

            for(int i=0;i<10;i++){

                System.out.println("InnerClass1中的method2方法i="+i);

                try{

                    Thread.sleep(100);

                }catch (InterruptedException e){

                    e.printStackTrace();

                }

}

            System.out.println(threadName+"离开InnerClass1中的method2方法");

        }

}

}

静态类内部两个方法，一个是静态的，另外一个是非静态的。静态方法锁的是类，非静态方法锁的是对象，两个互不冲突

public class Run {

    public static void main(String[] args){

        OutClass.InnerClass1 in1=new OutClass.InnerClass1();

        Thread t2=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method1();

            }

        },"T2");

        Thread t3=new Thread(new Runnable() {

            @Override

            public void run() {

                in1.method2();

            }

        },"T3");

        t2.start();

        t3.start();

    }

}

结果：

T2进入InnerClass1中的method1方法

T3进入InnerClass1中的method2方法

InnerClass1中的method1方法i=0

InnerClass1中的method2方法i=0

InnerClass1中的method2方法i=1

InnerClass1中的method1方法i=1

InnerClass1中的method2方法i=2

InnerClass1中的method1方法i=2

InnerClass1中的method2方法i=3

InnerClass1中的method1方法i=3

InnerClass1中的method1方法i=4

InnerClass1中的method2方法i=4

InnerClass1中的method1方法i=5

InnerClass1中的method2方法i=5

InnerClass1中的method2方法i=6

InnerClass1中的method1方法i=6

InnerClass1中的method1方法i=7

InnerClass1中的method2方法i=7

InnerClass1中的method2方法i=8

InnerClass1中的method1方法i=8

InnerClass1中的method2方法i=9

InnerClass1中的method1方法i=9

T3离开InnerClass1中的method2方法

T2离开InnerClass1中的method1方法

结果分析：由于两个线程不冲突，所以可以同时执行