系列文章目录

---

前言

java选手们应该都对锁不陌生，加锁了就是为保证操作语句的原子性，如果你是刚学并发编程，是否傻傻分不清楚对象锁和类锁呢？别怕！！！你看到了我的这篇文章就能帮你解决这个困惑~~

---

一、什么是锁竞争？

当我们使用synchronized个一个对象加上了锁，多个线程尝试在自己的内存空间上拿到这个加了锁的对象时，此时就会发生锁竞争，在竞争的瞬间只有一个线程可以拿到这个加了锁的对象，此时线程就是安全的。
举个例子：

假设你寝室里的卫生间只有一个马桶，某天晚上，你室友们同时都想去上厕所，那么你们就是要去抢这个厕所。
在这里你和你的室友就是线程；
厕所里的马桶就是对象；
厕所门上的锁就是synchronized；

二、什么是类锁？什么是实例对象锁？

类锁就是对类的成员或者方法或者类对象加锁，类锁本质就是对类对象加锁。

什么是类对象？
类对象就是.class对象，类对象详细的记录了程序员在定义这个类时全部的信息，比如：属性、方法等
你可以看到类对象是.class，类对象来源与.class文件，.class文件是由javac编译器根据.java源文件编译出来的，你可以理解成源文件只有一份，所以类对象也只有一份

类锁：
给static修饰的属性或者方法或者直接在synchronized(类.class)都是在给类加锁
实例对象锁：
给非static修饰的属性或者方法加锁

//给count加2000次
class A{
    static int count;
    //对静态方法加锁，就是对类对象加锁
   static synchronized void fun1(){
       for (int i = 0; i < 10000; i++) {
           count++;
       }
       System.out.println("我是类方法"+count);
   }

   //对实例方法加锁，就是对实例对象加锁
     synchronized void  fun2(){
        for (int i = 0; i < 10000; i++) {
            count++;
        }
       System.out.println("我是实例方法"+count);
   }
}

三、给类对象加锁不是锁住了整个类

是否线程安全，就看两个线程是否是针尝试获取到同一个加了锁的对象。就算里给类对象加了锁，也不是意味着一个线程拿到锁了，其他线程只能阻塞等待，如果其他线程本来就没有要去获取到这把类锁，而是去获取到实例对象的锁，那么这里就不存在多个线程竞争获取同一个对象竞争同一把锁。

看下面这段代码：

//线程不安全，t1和t2尝试获取的是两个不同的对象，一个是类对象，一个是实例对象，获取的不是同一把锁，不存在锁冲突
public class Test {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        //线程1获取到是static修饰的方法
        Thread t1 = new Thread(()->{
           A.fun1();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //线程2获取到的是非static修饰的方法
        Thread t2 = new Thread(()->{
           a.fun2();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

}
class A{
    static int count;
    //对静态方法加锁，就是对类对象加锁
   static synchronized void fun1(){
       for (int i = 0; i < 10000; i++) {
           count++;
       }
       System.out.println("我是类方法"+count);
   }

   //对实例方法加锁，就是对实例对象加锁
     synchronized void  fun2(){
        for (int i = 0; i < 10000; i++) {
            count++;
        }
       System.out.println("我是实例方法"+count);
   }
}

线程不安全，结果小于20000：

下面两段代码，多个线程就是在尝试获取同一锁
看下面这段代码：
t1、t2尝试获取同一把锁，实例对象锁

//t1和t2尝试获取到同一把锁，
public class Test {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        //线程1获取到是非static修饰的方法
        Thread t1 = new Thread(()->{
//           A.fun1();
            a.fun2();
        });
        //线程2获取到的是非static修饰的方法
        Thread t2 = new Thread(()->{
           a.fun2();
//            A.fun1();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

}
class A{
    static int count;
    //对静态方法加锁，就是对类对象加锁
   static synchronized void fun1(){
       for (int i = 0; i < 10000; i++) {
           count++;
       }
       System.out.println("我是类方法"+count);
   }

   //对实例方法加锁，就是对实例对象加锁
     synchronized void  fun2(){
        for (int i = 0; i < 10000; i++) {
            count++;
        }
       System.out.println("我是实例方法"+count);
   }
}

看下面一段代码：
t1和t2尝试获取到同一把类锁

public class Test {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        //线程1获取到是static修饰的方法
        Thread t1 = new Thread(()->{
           A.fun1();
//            a.fun2();
        });
        //线程2获取到的是static修饰的方法
        Thread t2 = new Thread(()->{
//           a.fun2();
            A.fun1();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

}
class A{
    static int count;
    //对静态方法加锁，就是对类对象加锁
   static synchronized void fun1(){
       for (int i = 0; i < 10000; i++) {
           count++;
       }
       System.out.println("我是类方法"+count);
   }

   //对实例方法加锁，就是对实例对象加锁
     synchronized void  fun2(){
        for (int i = 0; i < 10000; i++) {
            count++;
        }
       System.out.println("我是实例方法"+count);
   }
}

四、总结

多线安全是否安全和不单单只是看synchronized修饰的属性，因为java里的任何对象都可以被synchronized修饰，关键在于多个线程是否是尝试获取相同的锁对象，如果是同一把锁就会发送锁冲突，线程安全。否则就不存在锁冲突，线程不安全。
所以不要被类锁和对象锁的名称给迷晕了，就看多个线程是否是在获取同一把锁，如果是同一个实例对象锁，线程安全；如果是同一个类对象锁，线程安全；如果是一个线程获取类锁，一个线程获取实例对象锁，不安全。