这篇文章我们简单了解下java中实例锁和类锁。
在这里先给个福利，恶补下锁的作用：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
下面进入正题：
实例锁：对一个类的一个实例对象（对象A）进行加锁，防止其他线程同时访问对象A的synchronized块，但是对不同的此类的实例对象不做控制。实例锁使用Synchronized关键字修饰。
类锁：对一个类的所有实例对象进行加锁，限制多线程中该类的所有实例同时访问该类的synchronized块。类锁使用Static Synchronized关键字修饰。
文字比较生涩，我们看看代码：
实例锁
package com.xingshulin;
public class ObjectSyncTest implements Runnable {
int salary = 0;
public void run(){
addSalary();
}
public synchronized void addSalary() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
salary += 1;
System.out.println(salary);
}
public static void main(String[] args) {
ObjectSyncTest st = new ObjectSyncTest();
for (int i = 0; i < 10; i++) {
new Thread(st).start();
}
}
}
返回结果：
1
2
3
4
5
6
7
8
9
10
Process finished with exit code 0
代码很简单，我们可以看到addSalary方法是使用synchronized修饰的，所以它是实例锁。在main函数中我们使用了一个对象st，并生成了10个线程对st对象中的变量salary进行+1操作，可以看到最终结果确实是同步的。
有些童鞋会问了，那我要是把synchronized关键字去掉呢？其实这就是线程安全的问题了，在这里不多说，但是我们可以看下去掉后的返回值：
5
7
9
9
6
6
9
8
4
7
Process finished with exit code 0
很明显不对了是吧，再多试几遍，虽然每次得到的结果都不同，但是很明显都是不对的。这就是因为没有加同步锁，在程序运行中产生了线程冲突。
类锁
package com.xingshulin;
public class ClassSyncTest implements Runnable {
public static int salary = 0;
public void run(){
addSalary();
}
public static synchronized void addSalary() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
salary += 1;
System.out.println(salary);
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
ClassSyncTest st = new ClassSyncTest();
new Thread(st).start();
}
}
}
返回结果：
1
2
3
4
5
6
7
8
9
10
Process finished with exit code 0
结合实例锁的代码来看，对比很明显了。代码中addSalary方法是使用static synchronized关键字修饰的，所以它是类锁。而在main函数中使用了10个不同的对象st，每个对象都对变量salary进行+1操作，可以看到最终结果也是同步的。
为了证明确实类锁管用，我们把static关键字删掉（变成了实例锁），这样再跑下程序：
3
3
3
4
8
8
9
5
6
7
Process finished with exit code 0
很明显，线程又冲突了，所以也正好证明了实例锁只能管自己的一个实例，对于类中的所有实例是无法做到同步的。
