多线程java代码java多线程同步有几种实现方法java多线程同步方法

1基本概括

2主要介绍

2.1同步概念

2.1.1对象的内存布局

1实例数据：存放类的属性数据信息，包括父类的属性信息；

2对齐填充：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐；

3对象头：Java对象头一般占有2个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit，在64位虚拟机中，1个机器码是8个字节，也就是64bit），

但是如果对象是数组类型，则需要3个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数

组的大小，所以用一块来记录数组长度。

2.1.2Java对象头

Synchronized用的锁就是存在Java对象头里的，那么什么是Java对象头呢？Hotspot虚拟机的对象头主要包括两部分数据：

MarkWord（标记字段）、ClassPointer（类型指针）。其中ClassPointer是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，MarkWord用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键。Java对象头具体结构描述如下：

Java对象头结构组成

MarkWord用于存储对象自身的运行时数据，如：哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。比如锁膨胀就是借助MarkWord的偏向的线程ID、

下图是Java对象头无锁状态下MarkWord部分的存储结构（32位虚拟机）：

MarkWord存储结构

对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，MarkWord被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，MarkWord会随着程序的运行发生变化，可能变化为存储以下4种数据：

MarkWord可能存储4种数据

在64位虚拟机下，MarkWord是64bit大小的，其存储结构如下：

64位MarkWord存储结构

对象头的最后两位存储了锁的标志位，01是初始状态，未加锁，其对象头里存储的是对象本身的哈希码，随着锁级别的不同，对象头里会存储不同的内容。偏向锁存储的是当前占用此对象的线程ID；而轻量级则存储指向线程栈中锁记录的指针。从这里我们可以看到，“锁”这个东西，可能是个锁记录+对象头里的引用指针（判断线程是否拥有锁时将线程的锁记录地址和对象头里的指针地址比较)，也可能是对象头里的线程ID（判断线程是否拥有锁时将线程的ID和对象头里存储的线程ID比较）。

2.1.2对象头中MarkWord与线程中LockRecord

在线程进入同步代码块的时候，如果此同步对象没有被锁定，即它的锁标志位是01，则虚拟机首先在当前线程的栈中创建我们称之为“锁记录（LockRecord）”的空间，用于存储锁对象的MarkWord的拷贝，官方把这个拷贝称为DisplacedMarkWord。整个MarkWord及其拷贝至关重要。

LockRecord是线程私有的数据结构，每一个线程都有一个可用LockRecord列表，同时还有一个全局的可用列表。每一个被锁住的对象MarkWord都会和一个LockRecord关联（对象头的MarkWord中的LockWord指向LockRecord的起始地址），同时LockRecord中有一个Owner字段存放拥有该锁的线程的唯一标识（或者objectmarkword），表示该锁被这个线程占用。如下图所示为LockRecord的内部结构：

2.1.3监视器（Monitor）

任何一个对象都有一个Monitor与之关联，当且一个Monitor被持有后，它将处于锁定状态。Synchronized在JVM里的实现都是基于进入和退出Monitor对象来实现方法同步和代码块同步，虽然具体实现细节不一样，但是都可以通过成对的MonitorEnter和MonitorExit指令来实现。

1. MonitorEnter指令：插入在同步代码块的开始位置，当代码执行到该指令时，将会尝试获取该对象Monitor的所有权，即尝试获得该对象的锁；
2. MonitorExit指令：插入在方法结束处和异常处，JVM保证每个MonitorEnter必须有对应的MonitorExit；

那什么是Monitor？可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。

与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁。

也就是通常说Synchronized的对象锁，MarkWord锁标识位为10，其中指针指向的是Monitor对象的起始地址。在Java虚拟机（HotSpot）中，Monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的）：

ObjectMonitor(){_header=NULL;_count=0;//记录个数_waiters=0,_recursions=0;_object=NULL;_owner=NULL;_WaitSet=NULL;//处于wait状态的线程，会被加入到_WaitSet_WaitSetLock=0;_Responsible=NULL;_succ=NULL;_cxq=NULL;FreeNext=NULL;_EntryList=NULL;//处于等待锁block状态的线程，会被加入到该列表_SpinFreq=0;_SpinClock=0;OwnerIsThread=0;}

ObjectMonitor中有两个队列，_WaitSet和_EntryList，用来保存ObjectWaiter对象列表（每个等待锁的线程都会被封装成ObjectWaiter对象），

_owner指向持有ObjectMonitor对象的线程，当多个线程同时访问一段同步代码时：

首先会进入_EntryList集合，当线程获取到对象的monitor后，进入_Owner区域并把monitor中的owner变量设置为当前线程，同时monitor中的计数器count加1；若线程调用wait()方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入WaitSet集合中等待被唤醒；若当前线程执行完毕，也将释放monitor（锁）并复位count的值，以便其他线程进入获取monitor(锁)；

同时，Monitor对象存在于每个Java对象的对象头MarkWord中（存储的指针的指向），Synchronized锁便是通过这种方式获取锁的，也是为

什么Java中任意对象可以作为锁的原因，同时notify/notifyAll/wait等方法会使用到Monitor锁对象，所以必须在同步代码块中使用。

监视器Monitor有两种同步方式：互斥与协作。多线程环境下线程之间如果需要共享数据，需要解决互斥访问数据的问题，监视器可以确保监视器上

的数据在同一时刻只会有一个线程在访问。

什么时候需要协作？比如：

一个线程向缓冲区写数据，另一个线程从缓冲区读数据，如果读线程发现缓冲区为空就会等待，当写线程向缓冲区写入数据，就会唤醒读线程，这里读线程和写线程就是一个合作关系。

JVM通过Object类的wait方法来使自己等待，在调用wait方法后，该线程会释放它持有的监视器，直到其他线程通知它才有执行的机会。一个线程调用notify方法通知在等待的线程，这个

等待的线程并不会马上执行，而是要通知线程释放监视器后，它重新获取监视器才有执行的机会。如果刚好唤醒的这个线程需要的监视器被其他线程抢占，那么这个线程会继续等待。

Object类中的notifyAll方法可以解决这个问题，它可以唤醒所有等待的线程，总有一个线程执行。

如上图所示，一个线程通过1号门进入EntrySet(入口区)，如果在入口区没有线程等待，那么这个线程就会获取监视器成为监视器的Owner，然后执行监视区域的代码。如果在入口区中有其它线程在等待，

那么新来的线程也会和这些线程一起等待。线程在持有监视器的过程中，有两个选择，一个是正常执行监视器区域的代码，释放监视器，通过5号门退出监视器；还有可能等待某个条件的出现，于是它会通过3号门到WaitSet（等待区）休息，直到相应的条件满足后再通过4号门进入重新获取监视器再执行。

注意：

当一个线程释放监视器时，在入口区和等待区的等待线程都会去竞争监视器，如果入口区的线程赢了，会从2号门进入；如果等待区的线程赢了会从4号门进入。只有通过3号门才能进入等待区，在

等待区中的线程只有通过4号门才能退出等待区，也就是说一个线程只有在持有监视器时才能执行wait操作，处于等待的线程只有再次获得监视器才能退出等待状态。

2.2Synchronized原理

2.2.1Synchronized原理

实现原理：JVM是通过进入、退出对象监视器(Monitor)来实现对方法、同步块的同步的，而对象监视器的本质依赖于底层操作系统的互斥锁(MutexLock)实现。

具体实现是在编译之后在同步方法调用前加入一个monitor.enter指令，在退出方法和异常处插入monitor.exit的指令。

对于没有获取到锁的线程将会阻塞到方法入口处，直到获取锁的线程monitor.exit之后才能尝试继续获取锁。

流程图如下：

通过一段代码来演示:

publicstaticvoidmain(String[]args){synchronized(Synchronize.class){System.out.println("Synchronize");}}

使用javap-cSynchronize可以查看编译之后的具体信息。

可以看到在同步块的入口和出口分别有monitorenter和monitorexit指令。当执行monitorenter指令时，线程试图获取锁也就是获取monitor（monitor对象存在于每个Java对象的对象头中，synchronized锁便是

通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因）的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行monitorexit指令后，将锁计数器设为0，表明锁被释放。

如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

在synchronized修饰方法时是添加ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步

2.4.2synchronized的特点

2.3使用场景

2.3.1修饰实例方法，对当前实例对象this加锁

//即同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。publicclassSynchronized{publicsynchronizedvoidhusband(){}}

2.3.2修饰静态方法，对当前类的Class对象加锁

//其作用的范围是整个静态方法，作用的对象是这个类的所有对象。publicclassSynchronized{publicvoidhusband(){synchronized(Synchronized.class){}}}

2.3.3修饰代码块，指定一个加锁的对象，给对象加锁

//即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。publicclassSynchronized{publicvoidhusband(){synchronized(newtest()){}}}

2.4使用规则

2.5Synchronized与其他的对比

2.5.1Synchronized与ThreadLocal的比较（ThreadLocal详解）

1. Synchronized关键字主要解决多线程共享数据同步问题；ThreadLocal主要解决多线程中数据因并发产生不一致问题。
2. Synchronized是利用锁的机制，使变量或代码块只能被一个线程访问。而ThreadLocal为每一个线程都提供变量的副

本，使得每个线程访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

2.5.2Lock和synchronized的区别

1Lock是一个接口，而synchronized是关键字。

2synchronized会自动释放锁，而Lock必须手动释放锁。

3Lock可以让等待锁的线程响应中断，而synchronized不会，线程会一直等待下去。

4通过Lock可以知道线程有没有拿到锁，而synchronized不能。

5Lock能提高多个线程读操作的效率。

6synchronized能锁住类、方法和代码块，而Lock是块范围内的

2.5.3volatile和synchronized区别（volatile详解）

1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.

2）volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.

3）volatile仅能实现变量的修改可见性,而synchronized则可以保证变量的修改可见性和原子性.

  《Java编程思想》上说，定义long或double变量时，如果使用volatile关键字，就会获得（简单的赋值与返回操作）原子性。  4）volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.

5)当一个域的值依赖于它之前的值时，volatile就无法工作了，如n=n+1,n++等。如果某个域的值受到其他域的值的限制，那么volatile也无法工作，如Range类的lower和upper边界，必须遵循lower<=upper的限制。

6)使用volatile而不是synchronized的唯一安全的情况是类中只有一个可变的域。

2.5.4Synchronized和ReenTrantLock的对比

1）两者都是可重入锁

2）synchronized依赖于JVM而ReenTrantLock依赖于API

3）ReenTrantLock比synchronized增加了一些高级功能

①等待可中断；

②可实现公平锁；

③可实现选择性通知（锁可以绑定多个条件）

4)性能已不是选择标准

在JDK1.6之前，synchronized的性能是比ReenTrantLock差很多。具体表示为：synchronized关键字吞吐量随线程数的增加，下降得非常严重。而ReenTrantLock基本保持一个比较稳定的水平。

在JDK1.6之后JVM团队对synchronized关键字做了很多优化，性能基本能与ReenTrantLock持平。

2.6锁的优化

Java基础——Java多线程（synchronized详解）

3实现方式

3.1synchronized作用于实例方法

publicclasssynchronizedTestimplementsRunnable{//共享资源staticinti=0;/***synchronized修饰实例方法*/publicsynchronizedvoidincrease(){i++;}@Overridepublicvoidrun(){for(intj=0;j<10000;j++){increase();}}publicstaticvoidmain(String[]args)throwsInterruptedException{synchronizedTesttest=newsynchronizedTest();Threadt1=newThread(test);Threadt2=newThread(test);t1.start();t2.start();t1.join();t2.join();System.out.println(i);}}

3.2synchronized作用于静态方法

publicclasssynchronizedTestimplementsRunnable{//共享资源staticinti=0;/***synchronized修饰实例方法*/publicstaticsynchronizedvoidincrease(){i++;}@Overridepublicvoidrun(){for(intj=0;j<10000;j++){increase();}}publicstaticvoidmain(String[]args)throwsInterruptedException{Threadt1=newThread(newsynchronizedTest());Threadt2=newThread(newsynchronizedTest());t1.start();t2.start();t1.join();t2.join();System.out.println(i);}

3.3synchronized同步代码块

publicclasssynchronizedTestimplementsRunnable{staticsynchronizedTestinstance=newsynchronizedTest();staticinti=0;@Overridepublicvoidrun(){//省略其他耗时操作....//使用同步代码块对变量i进行同步操作,锁对象为instancesynchronized(instance){for(intj=0;j<10000;j++){i++;}}}publicstaticvoidmain(String[]args)throwsInterruptedException{Threadt1=newThread(instance);Threadt2=newThread(instance);t1.start();t2.start();t1.join();t2.join();System.out.println(i);}}

4常见问题

1Synchronized与ThreadLocal的比较？2Lock和synchronized的区别？3volatile和synchronized区别？4Synchronized和ReenTrantLock的对比5说说自己对于synchronized关键字的了解6synchronized关键字的三种使用7synchronized关键字的底层原理8JDK1.6之后对synchronized关键字进行的优化Java对象头的组成MarkWord的组成锁升级的过程偏向锁偏向锁的适用场景偏向锁的加锁偏向锁的撤销偏向锁的关闭轻量级锁轻量级锁的加锁轻量级锁的解锁轻量级锁的适用场景锁的优缺点对比总结synchronized关键字与ReentrantLock的区别共同点不同点9JVM是怎么通过synchronized在对象上实现加锁，保证多线程访问竞态资源安全的吗？10synchronized是公平锁还是非公平锁11Java中除了synchronized还有别的锁吗？