前言

在开发当中我们常常会遇到多线程安全的问题，java中给我们提供了一个同步锁的关键字synchronized，它很好的解决多线程安全问题，本章节主要讲解synchronized用法和写法，避免和多同学在用不知道该如何书写，如有理解不当之处，感谢指出。

一. synchronized锁的概念

对象锁

对象锁是用于对象实例方法，或者一个对象实例上的

类锁

类锁是用于类的静态方法或者一个类的class对象上的

1.1 什么样的是对象锁

下面我们通过code来讲解

public class User {
    private static final String TAG = "User";
    private Object o = new Object();

    public synchronized void updatePwd(){
        Log.d(TAG,"updatePwd");
    }

    public  void updateUserName(){
        synchronized (this){
            Log.d(TAG,"updateUserName");
        }
       Log.d(TAG,"updateUserName2");
    }

    public void deletePwd(){
        synchronized (o){
            Log.d(TAG,"deletePwd");
        }
        Log.d(TAG,"deletePwd2");
    }

通过代码我们可以看到，上面加了synchronized的3个函数，都可称为对象锁，不同的3种写法

1.1.1 第一种同步锁

加载方法上，对整个函数加锁，也就说到访问这个函数的时候就有了锁的标识

public synchronized void updatePwd(){
        Log.d(TAG,"updatePwd");
 }

1.1.2 第二种同步锁

对同步块加不同的对象锁，下面这俩种写法基本一样，对this进行同步是指对当前user对象，对o进行加锁是针对当前Object对象（这里需要注意，这种对象锁只是针对同一对象来说的，如果不同对象互不影响，后面具体讲解），下面这种写法和上面的区别是，我只同步函数体内的某一块代码，其他不做同步，也就意味这其他没有同步的代码不受锁的影响

public  void updateUserName(){
        synchronized (this){
            Log.d(TAG,"updateUserName");
        }
        Log.d(TAG,"updateUserName2");
    }

    public void deletePwd(){
        synchronized (o){
            Log.d(TAG,"deletePwd");
        }
         Log.d(TAG,"deletePwd2");
    }

1.2 什么样的是类锁

下面的这俩中写法都称类锁，指统一类对象的锁，就是说对user1，user2，user3...等在多线程访问的时候都会生效

public class User {
    private static final String TAG = "User";
    private Object o = new Object();

    public static synchronized void classUpdatePwd(){
        Log.d(TAG,"classUpdatePwd");
    }

    public  void classUpdateUserName(){
        synchronized (User.class){
            Log.d(TAG,"classUpdateUserName");
        }
    }
}

二. synchronized在多线程下的作用和用法

2.1 作用

某一块的共享数据，多个线程同时访问和操作，造成这一共享数据对这些线程不唯一

2.2 用法

2.2.1 对象锁的用法

下面代码可以看到，多线程对同一对象进行锁同步的操作，此时updatePwd函数如果被t1线程访问中，那么t2线程访问的时候需要等待t1线程执行完这个函数释放锁之后才能访问，也就是说同一个对象user的updatePwd资源只能在统一时间内被同一个线程操作，操作完之后才能被别的线程操作

public static void main(String[] args) {
        final User user = new User();
        //  t1线程和t2线程都在调用同一个对象的updatePwd方法，这里需要注意t1和t2代码书写上有前后关系，但运行的时候不一定t1先执行
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                user.updatePwd();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                user.updatePwd();
            }
        });
        t2.start();
    }

2.2.2 类锁的用法

这里与对象锁的区别是，类锁是指同类对象，就比如user1，user2，user3，都是User的对象，

public static void main(String[] args) {
        //  t1线程和t2线程分别对user1和user2的同名函数进行访问,在user1操作同名函数的时候，user2需要等待user1操作完释放锁才能操作
        final User user1 = new User();

        final User user2 = new User();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                user1.classUpdatePwd();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                user2.classUpdatePwd();
            }
        });
        t2.start();
    }

三. 总结

1。在多线程中对象锁无论是哪种写法都是针对统一对象的
2。类锁是针对同一类型对象的，多线程访问的时候，无论当前类的的哪个实例对象占有锁的时候，其他实例对象都需要等待
3。上面讲解的都是访问同一函数名，其实其他的函数也被上锁了，也是同样的原理，比如Thread1访问user中加了锁的synchronized a()函数，Thread2要访问user的synchronized b()函数，也是需要等Thread1释放了user的a锁，之后Thread2才能访问user的b函数

java同步锁synchronized几种使用的区别