【嵌牛导读】：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方法
结果分析：由于两个线程不冲突，所以可以同时执行
