主机托管业务百度运营优化师

系列文章目录

---

前言

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修饰，关键在于多个线程是否是尝试获取相同的锁对象，如果是同一把锁就会发送锁冲突，线程安全。否则就不存在锁冲突，线程不安全。
所以不要被类锁和对象锁的名称给迷晕了，就看多个线程是否是在获取同一把锁，如果是同一个实例对象锁，线程安全；如果是同一个类对象锁，线程安全；如果是一个线程获取类锁，一个线程获取实例对象锁，不安全。