Java多线程研究02-对象锁，synchronized关键字详解

红太狼 2022-07-20 12:13 219阅读 0赞

## 对象锁的概念 ##

**通过图理解一下，多个线程要操作同一个对象的场景**  
图1:  
![1：][1]  
图2：  
![2：][2]  
图3：  
![\[图片\]][20160724155555058]

## 解释： ##

● 钥匙是什么，可以理解为线程的执行资格，拥有cpu时间片等资源。

● 可是对象的‘锁芯’（对象独占权）只有一个，那么可以打开这把锁的多个‘钥匙’同一时间内只能有一把‘钥匙’进行操作；其他持有‘钥匙’的线程（或者没有持有钥匙的线程）都要进入等待状态；直到某把‘钥匙’从‘锁眼’中退出，操作系统会决定哪一把‘钥匙’重新插入‘锁芯’，这就是常说的操作系统的线程切换。

● 某一个线程拥有一个对象的‘锁’的‘钥匙’，并不代表这个线程的‘钥匙’是插入了‘锁芯’的（有这个对象的控制权）；但是，有权抢占‘锁芯’控制权的线程，必定拥有这个对象的‘钥匙’。

●请一定注意wait(time)的用法。很多人的理解都是：‘等待一段时间time，然后该线程激活继续工作’；但是实际上time更准确的含义应该是：到时检查。而整个wait(time)更准确的理解应该是：释放这个线程独占的X对象的锁芯（独占权），以便其它可以抢占‘锁芯’（独占权）的线程能够进行抢占，但是本线程继续持有X对象的锁的钥匙，等待time的时间后，重新参与‘锁芯’抢占（虽然不一定能够抢占得到）。

## 两个线程操作同一个对象时的流程描述 ##

1，线程1首先访问对象A，进入synchronized并拿到锁，拥有A的独占权。

2，线程2此时也访问对象A，但发现此时发现A的独占权已被其他线程占有，所以只能堵塞等待。

3，线程1对A的操作完成，归还钥匙并释独占资源，线程1对A的操作结束。

4，线程2发现A的独占权被释放，此时线程2由堵塞状态变为就绪状态，通过操作系统线程切换，线程2获得cpu执行资源（获得钥匙），并插入A的锁芯，拥有对A的独占权。

5，线程2执行完毕，归还钥匙释放A的独占权，线程2对A的操作结束。

**通过代码来理解一下**

package com.zczpeng.thread;
    
    public class SynchronizeTest {
        
    
        private static final Object THRAD_LOCK = new Object();
    
        public static void main(String[] args) {
    
            Thread threadA = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    synchronized (SynchronizeTest.THRAD_LOCK) {
                        System.out.println("线程A执行了");
                    }
                }
            });
           Thread threadB = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    synchronized (SynchronizeTest.THRAD_LOCK) {
                        System.out.println("线程B执行了");
                    }
                }
            });
    
           threadA.start();
           threadB.start();
        }
    }

## synchronized可标注的位置 ##

在JAVA中synchronized关键字可以加载很多位置。可以在一个方法定义上加synchronized关键字、也可以在方法体中加synchronized关键字、还可以在static块中加synchronized关键字。以下的代码都是正确的：

// 代码片段1
    static {
        synchronized(ThreadLock.class) {
    
        }
    }
    
    // 代码片段2
    public synchronized void someMethod() {
    
    }
    
    // 代码片段3
    public synchronized static void someMethod() {
    
    }
    
    // 代码片段4
    public static void someMethod() {
        synchronized (ThreadLock.class) {
    
        }
    }
    
    // 代码片段5
    public void someMethod() {
        synchronized (ThreadLock.class) {
    
        }
    }

**但是不同位置的synchronized的关键字，代表的含义是不一样的**

● synchronized关键字加载在非静态方法上时：  
其代表的含义和synchronized(this)\{\}的意义相同。即对所拥有这个方法的对象进行锁状态检查。

● synchronized关键字加载在静态方法上时：  
其代表的含义和synchronized(Class.class)的意义相类似。即对所拥有这个方法的类进行锁状态检查

## synchronized关键字的使用 ##

在前面的文章中我们主要讲解的是线程中“对象锁”的工作原理和操作方式。在讲解synchronized关键字的时候，我们还提到了synchronized关键字可以标注的位置。我们经常可以看到如下代码，将synchronized关键字加载到代码的方法体上，然后说，这个操作是线程安全的。

/**
     * 这个类的class对象进行检查。
     */
    public static synchronized void doSomething() {
    
    }
    
    /**
     * 对这个类的实例化对象进行检查
     */
    public synchronized void doOtherthing() {
    
    }

但事实上，**一个对象是否是线程安全的除了添加synchronized关键字以外，更重要的还要看如何进行这个对象的操作**。如下代码中，我们展示了在两个线程的doOtherthing方法（所谓的线程安全方法），去操作一个对象VALUE：

public class SyncThread implements Runnable {
        
    
    
        private Integer value;
    
        private static Integer VALUE;
    
    
        public SyncThread(int value) {
            this.value = value;
        }
    
        /**
         * 对这个类的实例化对象进行检查
         */
        private synchronized void doOtherthing() {
            VALUE= this.value;
    
            System.out.println("当前VALUE的值"+VALUE);
        }
    
        @Override
        public void run() {
            Thread currentThread = Thread.currentThread();
            Long id = currentThread.getId();
            this.doOtherthing();
        }
    
        public static void main(String[] args) throws Exception {
            Thread syncThread1 = new Thread(new SyncThread(10));
            Thread syncThread2 = new Thread(new SyncThread(100));
    
            syncThread1.start();
            syncThread2.start();
        }
    }

从Debug的情况来看，可能出现静态对象VALUE的值出现了脏读的情况：  
\[Thread-1\]当前VALUE的值：100  
\[Thread-0\] 当前VALUE的值：100

**以下是代码出现bug的原因：**  
● syncThread1对象和syncThread2对象是SyncThread类的两个不同实例。“private synchronized void doOtherthing()”方法中的synchronized关键字实际上进行同步检查目标是不一样的。

● 当然为了对这个类（SyncThread）的class对象进行同步检查，无需在静态方法上标注synchronized关键字，只要标注SyncThread的class对象进行同步检查。

private void doOtherthing() {
        synchronized (SyncThread.class) {
            VALUE = this.value;
            System.out.println("当前VALUE的值"+VALUE);
        }
    }

**所以，一个对象是否是线程安全的除了添加synchronized关键字以外，更重要的还要看如何进行这个对象的操作；标注了synchronized关键字的方法中，针对某个对象的操作不一定是线程安全的！**

[1]: /images/20220719/fcb194cddda84619bc37cd408528267a.png
[2]: /images/20220719/2a814e79b94a4ea5ab65f521bbcf312f.png
[20160724155555058]: /images/20220719/cb5432ac54e74d83b95b20eb3d8db563.png