概要 : 线程
Thread
进程 纤程/协程Fiber
进程与线程的区别
- 进程:操作系统资源分配的基本单位
- 线程:CPU执行的基本单位,也是一个进程里面最小的执行单元
一个CPU(核)在同一时刻可以执行几个线程?
除非有超线程存在,否则1个
线程切换
ALU: 运算单元
Register: 寄存器
PC: 程序计数器
Cache: 缓存
线程切换的时候,需要把寄存器和程序计数器中的内容保存(保护线程),然后在切换到其他线程执行,再切换回来。
JVM
是运行在操作系统之上的一个软件,线程分为操作系统级别的线程以及JVM
级别的纤程。JVM
规范中并未规定JVM
中的纤程和操作系统的线程如何对应,但是 HotSpot
中的实现是一一对应的。
synchronized
关键字在 jdk1.2
之前是重量级锁,所谓重量级,就是由操作系统来直接管理加锁以及释放锁的过程。后来经过一系列升级之后,synchronized
底层实现了 无锁 -> 偏向锁 -> 自旋锁 -> 重量级锁
的锁升级过程。
如果不是操作系统直接管理,可以由虚拟机来管理,JVM
自己来管理 保护线程
的操作,多个纤程对应一个线程。在运算简单但是需要很多线程来运算的场景,纤程的实现比直接使用线程快很多。
Synchronized 如何实现
介绍 synchronized
之前,要先了解对象在内存中的存储形式
对象的几个部分的作用:
-
对象头中的
Mark Word
(标记字)主要用来表示对象的线程锁状态,另外还可以用来配合GC
以及存放该对象的hashCode
; -
Klass Word
是一个指向方法区中Class
信息的指针,意味着该对象可随时知道自己是哪个Class
的实例; -
数组长度也是占用64位(8字节)的空间,这是可选的,只有当本对象是一个数组对象时才会有这个部分;
-
对象体是用于保存对象属性和值的主体部分,占用内存空间取决于对象的属性数量和类型;
-
对齐字是为了减少堆内存的碎片空间,提高内存读写效率。将整个对象占用的空间对齐为能被8字节整除;
一、MarkWord标记字
- 使用2bit标志位来表示不同的状态,无锁 -> 偏向锁 -> 自旋锁 -> 重量级锁
- 分代年龄: 占用4bit,所以最大值是15,
-XX:MaxTenuringThreshold
的最大值为15; identity_hashcode
:31位的对象标识hashCode
,采用延迟加载技术。调用方法System.identityHashCode()
计算,并会将结果写到该对象头中。当对象加锁后(偏向、轻量级、重量级),MarkWord
的字节没有足够的空间保存hashCode
,因此该值会移动到管程Monitor
中。thread
:持有偏向锁的线程ID。epoch
:偏向锁的时间戳。ptr_to_lock_record
:轻量级锁状态下,指向栈中锁记录的指针。ptr_to_heavyweight_monitor
:重量级锁状态下,指向对象监视器Monitor的指针。
重量级锁的问题
会造成线程排队(串行执行),且会使CPU
在用户态和核心态之间频繁切换,所以代价高、效率低。为了提高效率,不会一开始就使用重量级锁,JVM
在内部会根据需要,按如下步骤进行锁的升级:
-
初期锁对象刚创建时,还没有任何线程来竞争,对象的
Mark Word
是上图中第一种情形,这偏向锁标识位是0,锁状态01,说明该对象处于无锁状态(无线程竞争它)。 -
当有一个线程来竞争锁时,先用偏向锁,表示锁对象偏爱这个线程。
- 默认情况 偏向锁有个时延,默认是4秒:
- 因为JVM虚拟机自己有一些默认启动的线程,里面有好多sync代码,这些sync代码启动时就知道肯定会有竞争,如果使用偏向锁,就会造成偏向锁不断的进行锁撤销和锁升级的操作,效率较低。
这个线程要执行这个锁关联的任何代码,不需要再做任何检查和切换,这种竞争不激烈的情况下,效率非常高。这时Mark Word
会记录自己偏爱的线程的ID(加锁的过程),把该线程当做自己的熟人。如上图中第二种情形。
-
当有两个线程开始竞争这个锁对象,情况发生变化了,不再是偏向(独占)锁了,锁会升级为轻量级锁,两个线程公平竞争,哪个线程先占有锁对象并执行代码,锁对象的
Mark Word
就执行哪个线程的栈帧中的锁记录。如上图第3.1种情形。 -
如果竞争的这个锁对象的线程更多,导致了更多的切换和等待,
JVM
会把该锁对象的锁升级为重量级锁,这个就叫做同步锁,这个锁对象Mark Word
再次发生变化,会指向一个监视器对象,这个监视器对象用集合的形式,来登记和管理排队的线程。如上图第3.2种情形。 -
锁标志位为
(1,1)
时,表示该对象被GC
标记过了-XX:BiasedLockingStartupDelay=0
如果设定上述参数 new Object ()
将直接打开 101 偏向锁 -> 线程ID为0 -> Anonymous BiasedLock
打开偏向锁,new出来的对象,默认就是一个可偏向匿名对象101
JOL工具
jol是一款方便地打印对象内存内容的工具
// https://mvnrepository.com/artifact/org.openjdk.jol/jol-core
compile group: 'org.openjdk.jol', name: 'jol-core', version: '0.10'
public class JolTest {
private static AtomicInteger num = new AtomicInteger(0);
private static ConcurrentHashMap<String, Long> map = new ConcurrentHashMap<>();
public static void main(String[] args) {
// Object o = new Object();
// System.out.println(ClassLayout.parseInstance(o).toPrintable());
num.incrementAndGet();
map.put("abc", 100L);
try {
// sleep 4秒之后偏向锁启动
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
User u = new User();
u.setId(12);
// System.out.println(ClassLayout.parseInstance(u).toPrintable());
u.setCode(Long.MAX_VALUE);
u.setName("张三");
System.out.println(ClassLayout.parseInstance(u).toPrintable());
// 无锁状态
synchronized (u) {
System.out.println(ClassLayout.parseInstance(u).toPrintable());
}
System.gc();
System.out.println(ClassLayout.parseInstance(u).toPrintable());
}
}
synchronized
代码实现
Java
层级
synchronized (o)
- 字节码层级
monitorenter moniterexit
JVM
层级(Hotspot
)
package com.mashibing.insidesync;
public class T01_Sync1 {
public static void main(String[] args) {
Object o = new Object();
System.out.println(ClassLayout.parseInstance(o).toPrintable());
}
}
com.mashibing.insidesync.T01_Sync1$Lock object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) 49 ce 00 20 (01001001 11001110 00000000 00100000) (536923721)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
com.mashibing.insidesync.T02_Sync2$Lock object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 05 90 2e 1e (00000101 10010000 00101110 00011110) (506368005)
4 4 (object header) 1b 02 00 00 (00011011 00000010 00000000 00000000) (539)
8 4 (object header) 49 ce 00 20 (01001001 11001110 00000000 00100000) (536923721)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes tota
InterpreterRuntime::monitorenter
方法
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
if (PrintBiasedLockingStatistics) {
Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
}
Handle h_obj(thread, elem->obj());
assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
"must be NULL or an object");
if (UseBiasedLocking) {
// Retry fast entry if bias is revoked to avoid unnecessary inflation
ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
} else {
ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
}
assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
"must be NULL or an object");
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END
synchronizer.cpp
revoke_and_rebias
void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS) {
if (UseBiasedLocking) {
if (!SafepointSynchronize::is_at_safepoint()) {
BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
return;
}
} else {
assert(!attempt_rebias, "can not rebias toward VM thread");
BiasedLocking::revoke_at_safepoint(obj);
}
assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
}
slow_enter (obj, lock, THREAD) ;
}
void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
markOop mark = obj->mark();
assert(!mark->has_bias_pattern(), "should not see bias pattern here");
if (mark->is_neutral()) {
// Anticipate successful CAS -- the ST of the displaced mark must
// be visible <= the ST performed by the CAS.
lock->set_displaced_header(mark);
if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
TEVENT (slow_enter: release stacklock) ;
return ;
}
// Fall through to inflate() ...
} else
if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
assert(lock != mark->locker(), "must not re-lock the same lock");
assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
lock->set_displaced_header(NULL);
return;
}
#if 0
// The following optimization isn't particularly useful.
if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
lock->set_displaced_header (NULL) ;
return ;
}
#endif
// The object header will never be displaced to this lock,
// so it does not matter what the value is, except that it
// must be non-zero to avoid looking like a re-entrant lock,
// and must not look locked either.
lock->set_displaced_header(markOopDesc::unused_mark());
ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
}
inflate
方法:膨胀为重量级锁