synchronized关键字

最新推荐文章于 2024-11-21 09:59:30 发布

JavaCodeGirl

最新推荐文章于 2024-11-21 09:59:30 发布

阅读量282

点赞数 3

分类专栏：并发编程

本文链接：https://blog.youkuaiyun.com/qq_32428485/article/details/112381687

版权

多线程 java synchronized

并发编程专栏收录该内容

19 篇文章

订阅专栏

并发编程的重点也是难点是数据同步、线程安全、锁。要编写线程安全的代码，其核心在于对共享和可变的状态的访问进行管理。

共享意味着变量可以由多个线程访问，而可变则意味着变量的值在其生命周期内可以发生变化。

当多个线程访问某个状态变量且其中有一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。

Java中的主要同步机制是关键字synchronized，它提供了一种独占的加锁方式。

勾勾从一下几个方面来学习synchronized：

关键字synchronized的特性

synchronized关键字可以实现一个简单的策略来防止线程干扰和内存一致性错误，如果一个对象对多个线程是可见的，那么该对象的所有读和写都需通过同步的方式。

synchronized的特性：

不可中断

synchronized关键字提供了独占的加锁方式，一旦一个线程持有了锁对象，其他线程将进入阻塞状态或者等待状态，直到前一个线程释放锁，中间过程不可中断。
原子性

synchronized关键字的不可中断性保证了它的原子性。

可见性
synchronized关键字包含了两个JVM指令：monitor enter和monitor exit，它能够保证在任何时候任何线程执行到monitor enter时都必须从主内存中获取数据，而不是从线程工作内存获取数据，在monitor exit之后，工作内存被更新后的值必须存入主内存，从而保证了数据可见性。
有序性

synchronized关键字修改的同步方法是串行执行的，但其所修饰的代码块中的指令顺序还是会发生改变的，这种改变遵守java happens-before规则。
可重入性

如果一个拥有锁持有权的线程再次获取锁，则monitor的计数器会累加1，当线程释放锁的时候也会减1，直到计数器为0表示线程释放了锁的持有权，在计数器不为0之前，其他线程都处于阻塞状态。

关键字synchronized的用法

synchronized关键字锁的是对象，修饰的可以是代码块和方法，但是不能修饰class对象以及变量。

代码块，锁对象即是object

public void sync(){        synchronized (new Object()){                            }           }

方法，锁对象即是this

 public synchronized void syncMethod(){   }

静态方法，锁对象既是class

 public synchronized static void syncStaticMethod(){   }

勾勾在开发中最常用的是用synchronized关键字修饰对象，可以控制锁的粒度，所以针对最常用的场景勾勾去了解了它的字节码文件，先来看看勾勾的测试用例：

public class TestSynchronized {    private int index;    private final static int MAX = 100;    public void sync(){               synchronized (new Object()){                            while (index < MAX){                                        index ++;            }        }    }}

运行命令 “javac -encoding UTF-8 TestSynchronized.java”编辑成class文件，然后

运行命令“javap -c TestSynchronized.class”得到字节码文件：

 public com.example.demo.articles.thread.TestSynchronized();     Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V       4: return  public void sync();    Code:       0: new           #2                  // class java/lang/Object       3: dup       4: invokespecial #1                  // Method java/lang/Object."<init>":()V       7: dup       8: astore_1       9: monitorenter  //进入同步代码块      10: aload_0       //加载数据      11: getfield      #3                  // Field index:I      14: bipush        100      16: if_icmpge     32      19: aload_0      20: dup      21: getfield      #3                  // Field index:I      24: iconst_1      25: iadd          // 加1操作      26: putfield      #3                  // Field index:I      29: goto          10 //跳转至10行      32: aload_1            33: monitorexit  // 退出同步代码块      34: goto          42 //跳转至42行      37: astore_2     // 刷新数据      38: aload_1      39: monitorexit        40: aload_2      41: athrow      42: return    Exception table:       from    to  target type          10    34    37   any          37    40    37   any}

monitorenter和monitorexit是成对出现的，有时候你看到的是一个monitorenter对应多个monitorexit，但是能肯定的一定点是每一个monitorexit之前必有一个monitorenter。

从字节码文件中可以看到monitorenter之后执行了aload操作，monitorexit之后执行了astore操作。

TIPS：在使用synchronized关键字时注意事项

锁的对象不能为空；
锁的范围不宜太大；
不要试图使用不同的monitor来锁同一个方法；
避免多个锁交叉等待导致死锁；

锁膨胀

在jdk1.6之前，线程在获取锁时，如果锁对象已经被其他线程持有，此线程将挂起进入阻塞状态，唤醒阻塞线程的过程涉及到了用户态和内核态的切换，性能损耗比较大。

synchronized作为亲儿子，混的太差肯定不行，在jdk1.6对其进行了优化，将锁状态分为了无锁状态，偏向锁，轻量级锁，重量级锁。

锁的升级过程既是：

在了解锁的升级过程之前，勾勾重点理解了monitor和对象头。

在第一次研究锁膨胀的时候因为没有花时间去理解这两个概念，勾勾对锁升级的记忆只持续了3天，最后勾勾又用了两天的时间去学习对象头和monitor，才算是真正的理解锁的膨胀原理。所以大家在学习一个知识的时候，不要靠背去记忆一个知识点，一定要知其然。

每一个对象都与一个monitor相关联，monitor对象与实例对象一同创建并销毁，monitor是C++支持的一个监视器。锁对象的争夺既是争夺monitor的持有权。

勾勾在OpenJdk源码中找到了ObjectMonitor的源码：

 // initialize the monitor, exception the semaphore, all other fields  //  are simple integers or pointers      ObjectMonitor() {      _header       = NULL;    _count        = 0;    _waiters      = 0,    _recursions   = 0;    _object       = NULL;    _owner        = NULL;    _WaitSet      = NULL;    _WaitSetLock  = 0 ;    _Responsible  = NULL ;    _succ         = NULL ;    _cxq          = NULL ;    FreeNext      = NULL ;    _EntryList    = NULL ;    _SpinFreq     = 0 ;    _SpinClock    = 0 ;    OwnerIsThread = 0 ;  } protected:                         // protected for jvmtiRawMonitor  void *  volatile _owner;          // pointer to owning thread OR BasicLock  volatile intptr_t  _recursions;   // recursion count, 0 for first entry private:  int OwnerIsThread ;               // _owner is (Thread *) vs SP/BasicLock  ObjectWaiter * volatile _cxq ;    // LL of recently-arrived threads blocked on entry.                                    // The list is actually composed of WaitNodes, acting                                    // as proxies for Threads. protected:  ObjectWaiter * volatile _EntryList ;     // Threads blocked on entry or reentry. private:  Thread * volatile _succ ;          // Heir presumptive thread - used for futile wakeup throttling  Thread * volatile _Responsible ;  int _PromptDrain ;                // rqst to drain cxq into EntryList ASAP}

owner：指向线程的指针。即锁对象关联的monitor中的owner指向了哪个线程表示此线程持有了锁对象。

waitSet：进入阻塞等待的线程队列。当线程调用wait方法之后，就会进入waitset队列，可以等待其他线程唤醒。

entryList：当多个线程进入同步代码块之后，处于阻塞状态的线程就会被放入entryList中。

那什么是对象头呢，它与synchronized又有什么关系呢？

在JVM中，对象在内存中分为3块区域：

对象头

Mark Word（标记字段）：用于存储对象的hashcode，分代年龄，锁标志位，是否可偏向标志，在运行期间，其存储的数据会发生变化。

Klass Point（类型指针）：该指针指向它的类元数据，JVM通过这个指针确定对象是哪个类的实例。该指针的位长度为JVM的一个字大小，即32位的JVM为32位，64位的JVM为64位。
实例数据

用于存放类的数据信息
填充数据

虚拟机要求对象起始地址必须是8字节的整数倍，当不满足时需对其填充。