锁的作用
锁是一种线程同步机制，用于实现互斥，当线程占用一个对象锁的时候，其它线程如果也想使用这个对象锁就需要排队。如果不使用对象锁，不同的线程同时操作一个变量的时候，有可能导致错误。让我们做一个测试：
class Entity {
public int value = 0;
}
class IncreaseThread implements Runnable {
@Override
public void run() {
for(int i=0;i < 100000; i++) {
AndOneTest.instance.value++;
}
}
}
public class AndOneTest {
public static Entity instance = new Entity();
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new IncreaseThread());
exec.execute(new IncreaseThread());
exec.shutdown();
Thread.sleep(5000);//等待两个线程执行结束
System.out.println("Value = " + instance.value);
}
}
5秒后输出以下结果，如果重新运行程序，得出的结果还会不同：
Value = 111260
我们创建了两个线程，这两个线程同时对AddOneTest.value执行十万次自增操作，我们期望的值是200000，然而得到的结果却并不是。假设两个线程都要对int value=0变量实现value++操作，value++操作会被虚拟机分成三步执行，
1.读取value当前的值。
2.将这个值加1。
3.将加1的结果写入value变量。
两个线程执行的顺序有可能是：
1.线程一读取value值（0）
2.线程二读取value值（0）
3.线程一将值加1(1)
4.线程二将值加1(1)
5.线程一将结果写入value变量（1）
6.线程二将结果写入value变量（1）
最后两个线程执行的结果是i=1，而不是i=2。因此我们无法得到Value =200000。线程之间的运行顺序的可不预测性会导致我们得不到正确的结果，因此我们需要加锁来保证结果是正确的。
Java内置锁
内置锁使用synchronized关键字定义，synchronized关键字有两种使用方法，一种是作为修饰词定义在方法中代码如下：
public synchronized void test() {
//临界区
}
另一种是指定一个对象，后面接一个代码块，代码如下：
public void test() {
synchronized(object) {
//临界区
}
}
二者有两个区别：
1． 锁的对象不同，第一种方式获取的是当前对象的锁，相当于synchronized(this){}，第二种方法获取的是指定对象的锁。
2． 作用域不同，第一种方式锁的是整个方法，第二种锁的只是代码块内部。
使用锁对上例自增测试的改进，只需要在AndOneTest.instance.value++外面加上如下代码即可：
synchronized(AndOneTest.instance) {
AndOneTest.instance.value++;
}
运行后5秒后输出以下结果：
Value = 200000
这里有个需要注意的地方：1. 所有的锁都对应一个对象，同一个对象锁之间会互斥；2. 不同对象锁之间不会互斥；3. 没有申请锁的方法不和任何对象锁互斥。因此我们需要对哪个对象进行修改的时候就获取哪个对象的锁，这样就可以保证不同的线程不会同时修改这个对象。如果需要对两个对象修改，则应分别获取两个对象的锁，代码如下：
public void change() {
synchronized(instanceA) {
//对instanceA进行修改
}//释放对instanceA的锁
synchronized(instanceB) {
//对instanceB进行修改
}//释放对instanceB的锁
}
当synchronized关键字修饰static方法时，获取的就不是当前对象的锁了，而是类对象锁，因为调用static方法时可能类还没有对象。实际上类锁也有一个对应的对象，它所对应的对象是ClassName.class。这个对象用于存储类信息的，在使用反射的时候经常使用到。
class TargetClass{
public synchronized static void sleepMethod() {
try {
Thread.sleep(3000);//睡3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我睡醒了");
}
public synchronized static void getLockMethod() {
synchronized(Target.class) {
System.out.println("我得到了class锁");
}
}
}
class ExampleThread implements Runnable {
@Override
public void run() {
TargetClass.sleepMethod();
}
}
public class StaticLockTest {
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExampleThread());
exec.shutdown();
Thread.sleep(100);//等待新创建的线程获得锁
TargetClass.getLockMethod();
}
}
3秒钟之后输出以下结果：
我睡醒了
我得到了class锁
执行main()方法的线程我们称之为主线程，此外我们还通过线程池创建了一个新的线程，新线程执行sleepMethod()，主线程执行getLockMethod()。启动新线程后主线程会等待新线程0.1秒，以确保新线程拿到了锁，0.1秒之后，主线程想获得锁，但是锁已经被占用了，只能等到新线程执行完sleepMethod()方法。本例中synchronized static synchronized(TargetClass.class){}等价，获得的都是TargetClass.class对象的锁。
总结
未完待续。
公众号：今日说码。关注我的公众号，可查看连载文章。遇到不理解的问题，直接在公众号留言即可。