小丑西瓜9

这个屌丝很懒，什么也没留下！

热门标签

synchronized(this) 与synchronized(class) 之间的区别--对象锁和类锁_synchronized class

作者：小丑西瓜9 | 2024-03-23 01:00:58

踩

synchronized class

synchronized(this) 与synchronized(class) 之间的区别

一、概念

synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。

锁机制有如下两种特性：

互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，这样在同一时间只有一个线程对需同步的代码块(复合操作)进行访问。互斥性我们也往往称为操作的原子性。
可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作从而引起不一致。

二、对象锁和类锁

1. 对象锁

在 Java 中，每个对象都会有一个 monitor 对象，这个对象其实就是 Java 对象的锁，通常会被称为“内置锁”或“对象锁”。类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰。

2. 类锁

在 Java 中，针对每个类也有一个锁，可以称为“类锁”，类锁实际上是通过对象锁实现的，即类的 Class 对象锁。每个类只有一个 Class 对象，所以每个类只有一个类锁。

三、synchronized 的用法分类

synchronized 的用法可以从两个维度上面分类：

1. 根据修饰对象分类

synchronized 可以修饰方法和代码块

修饰代码块
- synchronized(this|object) {}
- synchronized(类.class) {}
修饰方法
- 修饰非静态方法
- 修饰静态方法

2. 根据获取的锁分类

获取对象锁
- synchronized(this|object) {}
- 修饰非静态方法
获取类锁
- synchronized(类.class) {}
- 修饰静态方法，非静态方法

四、synchronized 的用法详解

这里根据获取的锁分类来分析 synchronized 的用法

1、对象锁

这个对象是新建的，跟其他对象没有任何关系：

/**
     * synchronized 修饰非静态方法
     */
    private void sync5() {
        Log.d(TAG,Thread.currentThread().getName() + "_Sync5: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        synchronized (new SyncThread()) {
            try {
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

文章后面所有例子都是采用这四个线程，只是对方法进行修改：

SyncThread syncThread = new SyncThread();
        Thread F_thread1 = new Thread(new SyncThread(), "F_thread1");
        Thread F_thread2 = new Thread(new SyncThread(), "F_thread2");
        Thread F_thread3 = new Thread(syncThread, "F_thread3");
        Thread F_thread4 = new Thread(syncThread, "F_thread4");
        F_thread1.start();
        F_thread2.start();
        F_thread3.start();
        F_thread4.start();
1
2
3
4
5
6
7
8
9

运行结果如下：

四个线程同时开始，同时结束，因为作为锁的对象与线程是属于不同的实例。

2、采用类锁，无所谓哪个类，都会被拦截：

/**
     * synchronized 修饰非静态方法
     */
    private void sync5() {
        Log.d(TAG,Thread.currentThread().getName() + "_Sync5: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        synchronized (MainActivity.class) {
            try {
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果如下：

可以发现，采用类锁一次只能通过一个。即使采用的是 MainActivity.class 这个类锁。

3、采用 this 对象锁：

/**
     * synchronized 修饰非静态方法
     */
    private void sync5() {
        Log.d(TAG,Thread.currentThread().getName() + "_Sync5: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        synchronized (this) {
            try {
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                Log.d(TAG, Thread.currentThread().getName() + "_Sync5_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果如下：

可以发现线程1，2同时结束，3，4有先后，原因是3，4同属于一个实例。

4、synchronized 修饰方法

作用范围是整个方法，所以方法中所有的代码都是同步的：

/**
     * synchronized 修饰非静态方法
     */
    private synchronized void sync5() {
        Log.d(TAG, Thread.currentThread().getName() + "_Sync5: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            Log.d(TAG, Thread.currentThread().getName() + "_Sync5_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            Log.d(TAG, Thread.currentThread().getName() + "_Sync5_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

修饰非静态方法：

对于非静态方法，同一个实例的线程访问会被拦截，非同一实例可以同时访问。即此时是默认对象锁（this）。

修饰静态方法结果

可以看出来，静态方法默认类锁。

总结

1、对于静态方法，由于此时对象还未生成，所以只能采用类锁；

2、只要采用类锁，就会拦截所有线程，只能让一个线程访问。

3、对于对象锁（this），如果是同一个实例，就会按顺序访问，但是如果是不同实例，就可以同时访问。

4、如果对象锁跟访问的对象没有关系，那么就会都同时访问。

参考文章：Java 之 synchronized 详解

树林美丽、幽暗而深邃，但我有诺言尚待实现，还要奔行百里方可沉睡。 -- 罗伯特·弗罗斯特

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/292087?site