多线程场景对共享资源的计算、使用，必不可少的会出现锁的身影。如果不能准确的使用锁会影响计算结果的准确性，如多线程操作数据库不能合理的创建连接、控制并发访问可能导致数据库服务崩溃。

如下我们简单的了解非静态对象锁、静态对象锁、类锁区别。

非静态对象锁

public final Object LOCK = new Object();

创建不同对象打印成员变量LOCK的地址值发现，地址值不同。

for (int index = 1; index <= 10; index++) {
    System.out.println(new Lock().LOCK);
}

------
java.lang.Object@14ae5a5
java.lang.Object@7f31245a
java.lang.Object@6d6f6e28
java.lang.Object@135fbaa4
java.lang.Object@45ee12a7
java.lang.Object@330bedb4
java.lang.Object@2503dbd3
java.lang.Object@4b67cf4d
java.lang.Object@7ea987ac
java.lang.Object@12a3a380

静态对象锁

static关键字修饰，随着类的加载而加载。

public final static Object STATIC_LOCK = new Object();

创建不同对象打印成员变量STATIC_LOCK的地址值发现，地址值相同。

for (int index = 1; index <= 10; index++) {
    System.out.println(new Lock().STATIC_LOCK);
}

------
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5
java.lang.Object@14ae5a5

代码测试

package com.lock.test;

class Lock implements Runnable {
    public final Object LOCK = new Object();
    public final static Object STATIC_LOCK = new Object();
    private String type;
    private static int count = 0;

    public Lock() {
    }

    public Lock(String type) {
        this.type = type;
    }


    private void objectLock() {
        synchronized (LOCK) {
            while (++count < 10) {
                System.out.println(count);
            }
        }
    }

    private void staticObjectLock() {
        synchronized (STATIC_LOCK) {
            while (++count < 10) {
                System.out.println(count);
            }

        }
    }

    private void staticLock() {
        synchronized (Lock.class) {
            while (++count < 10) {
                System.out.println(count);
            }
        }
    }

    public void run() {
        if ("object".equals(type)) {
            objectLock();
        } else if ("static".equals(type)) {
            staticLock();
        } else if ("staticObject".equals(type)) {
            staticObjectLock();
        } else {
            throw new IllegalArgumentException("参数异常...");
        }
    }
}

package com.lock.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ObjectLock {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        //对象锁-同一个对象--正常
        Lock lock = new Lock("object");
        for (int index = 1; index <= 10; index++) {
            pool.execute(lock);
        }
        //对象锁-不同对象--异常
        for (int index = 1; index <= 10; index++) {
            pool.execute(new Lock("object"));
        }
        //静态对象锁-不同对象--正常
        for (int index = 1; index <= 10; index++) {
            pool.execute(new Lock("staticObject"));
        }
        //类锁-同一个对象--正常
        Lock lock_static = new Lock("static");
        for (int index = 1; index <= 10; index++) {
            pool.execute(lock_static);
        }
        //类锁-不同对象--正常
        for (int index = 1; index <= 10; index++) {
            pool.execute(new Lock("static"));
        }
        pool.shutdownNow();
    }
}

非静态对象锁-同一个对象：线程安全 非静态对象锁-不同对象：线程不安全 静态对象锁-不同对象：线程安全 类锁-同一个对象：线程安全 类锁-不同对象：线程安全

总结

多线程操作，使用锁需保证锁对象唯一。static关键字修饰锁对象说明该成员变量随着类的加载而加载，地址唯一。类锁，类文件唯一。 以上验证均为同一个jvm中，如分布式计算请选择使用分布式锁。