1

2

3

4

5

6

7

8

9

10

11

12

13

public?class?TestDemo {

}

public?class?DemoExample1 {

????static?TestDemo testDemo;

????public?static?void?main(String[] args) throws Exception {

????????testDemo=?new?TestDemo();

????????synchronized (testDemo){

????????????System.out.println("lock ing");

????????????testDemo.hashCode();

????????????System.out.println(ClassLayout.parseInstance(testDemo).toPrintable());

????????}

????}

}

1

javap -c DemoExample1.class

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

public?class?DemoExample3 {

????public?int?sharedState;

?

????public?void?nonSafeAction() {

????????while?(sharedState <?100000) {

????????????int?former = sharedState++;

????????????int?latter = sharedState;

????????????if?(former != latter -?1) {

????????????????System.out.println("Observed data race, former is "?+

????????????????????????former +?", "?+?"latter is "?+ latter);

????????????}

????????}

????}

??

????public?static?void?main(String[] args)?throws?InterruptedException {

????????final?DemoExample3 demoExample3 =?new?DemoExample3();

????????Thread thread1 =?new?Thread() {

????????????@Override

????????????public?void?run() {

????????????????demoExample3.nonSafeAction();

????????????}

????????};

???

????????Thread thread2 =?new?Thread() {

????????????@Override

????????????public?void?run() {

????????????????demoExample3.nonSafeAction();

????????????}

????????};

?

????????thread1.start();

????????thread2.start();

????????thread1.join();

????????thread2.join();

????}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public?class?DemoExample3 {

????public?int?sharedState;

???

????public?void?nonSafeAction() {

????????while?(sharedState <?100000) {

????????????synchronized?(this) {

????????????????int?former = sharedState++;

????????????????int?latter = sharedState;

????????????????if?(former != latter -?1) {

????????????????????System.out.println("Observed data race, former is "?+

????????????????????????????former +?", "?+?"latter is "?+ latter);

????????????????}

????????????}

????????}

????}

???

????public?static?void?main(String[] args)?throws?InterruptedException {

????????final?DemoExample3 demoExample3 =?new?DemoExample3();

????????Thread thread1 =?new?Thread() {

????????????@Override

????????????public?void?run() {

????????????????demoExample3.nonSafeAction();

????????????}

????????};

???

????????Thread thread2 =?new?Thread() {

????????????@Override

????????????public?void?run() {

????????????????demoExample3.nonSafeAction();

????????????}

????????};

????????thread1.start();

????????thread2.start();

????????thread1.join();

????????thread2.join();

????}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

// Handles the uncommon case in locking, i.e., contention or an inflated lock.

JRT_BLOCK_ENTRY(void, SharedRuntime::complete_monitor_locking_C(oopDesc* _obj, BasicLock* lock, JavaThread*?thread))

??// Disable ObjectSynchronizer::quick_enter() in default config

??// on AARCH64 and ARM until JDK-8153107 is resolved.

??if?(ARM_ONLY((SyncFlags & 256) != 0 &&)

??????AARCH64_ONLY((SyncFlags & 256) != 0 &&)

??????!SafepointSynchronize::is_synchronizing()) {

????// Only try quick_enter() if we're not trying to reach a safepoint

????// so that the calling thread reaches the safepoint more quickly.

????if?(ObjectSynchronizer::quick_enter(_obj,?thread, lock))?return;

??}

??// NO_ASYNC required because an async exception on the state transition destructor

??// would leave you with the lock held and it would never be released.

??// The normal monitorenter NullPointerException is thrown without acquiring a lock

??// and the model is that an exception implies the method failed.

??JRT_BLOCK_NO_ASYNC

??oop obj(_obj);

??if?(PrintBiasedLockingStatistics) {

????Atomic::inc(BiasedLocking::slow_path_entry_count_addr());

??}

??Handle h_obj(THREAD, obj);

??//在 JVM 啟動時，我們可以指定是否開啟偏向鎖

??if?(UseBiasedLocking) {

??// Retry fast entry if bias is revoked to avoid unnecessary inflation

?<strong>?//fast_enter 是我們熟悉的完整鎖獲取路徑</strong>

????ObjectSynchronizer::fast_enter(h_obj, lock,?true, CHECK);

??}?else?{

??//slow_enter 則是繞過偏向鎖，直接進入輕量級鎖獲取邏輯

????ObjectSynchronizer::slow_enter(h_obj, lock, CHECK);

??}

??assert(!HAS_PENDING_EXCEPTION,?"Should have no exception here");

??JRT_BLOCK_END

JRT_END

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

// -----------------------------------------------------------------------------

//? Fast Monitor Enter/Exit

// This the fast monitor enter. The interpreter and compiler use

// some assembly copies of this code. Make sure update those code

// if the following function is changed. The implementation is

// extremely sensitive to race condition. Be careful.

void?ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock,

????????????????????????????????????bool?attempt_rebias, TRAPS) {

??if?(UseBiasedLocking) {

????if?(!SafepointSynchronize::is_at_safepoint()) {

??????//biasedLocking定義了偏向鎖相關操作，revoke_and_rebias revokeatsafepoint 則定義了當檢測到安全點時的處理

??????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，鎖升級

??slow_enter(obj, lock, THREAD);

}

??

// -----------------------------------------------------------------------------

// Interpreter/Compiler Slow Case

// This routine is used to handle interpreter/compiler slow case

// We don't need to use fast path here, because it must have been

// failed in the interpreter/compiler code.

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.

????// 將目前的 Mark Word 復制到 Displaced Header 上

????lock->set_displaced_header(mark);

????// 利用 CAS 設置對象的 Mark Wo

????if?(mark == obj()->cas_set_mark((markOop) lock, mark)) {

??????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;

??}

??// 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.

??// 重置 Displaced Header

??lock->set_displaced_header(markOopDesc::unused_mark());

??//鎖膨脹

??ObjectSynchronizer::inflate(THREAD,

??????????????????????????????obj(),

??????????????????????????????inflate_cause_monitor_enter)->enter(THREAD);

}

// This routine is used to handle interpreter/compiler slow case

// We don't need to use fast path here, because it must have

// failed in the interpreter/compiler code. Simply use the heavy

// weight monitor should be ok, unless someone find otherwise.

void?ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) {

??fast_exit(object, lock, THREAD);

}

??

//鎖膨脹

ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {

??// Inflate mutates the heap ...

??// Relaxing assertion for bug 6320749.

??assert?(Universe::verify_in_progress() ||

??????????!SafepointSynchronize::is_at_safepoint(),?"invariant") ;

??

??

??for?(;;) {//自旋

??????const?markOop mark = object->mark() ;

??????assert?(!mark->has_bias_pattern(),?"invariant") ;

??

??????// The mark can be in one of the following states:

??????// *? Inflated???? - just return

??????// *? Stack-locked - coerce it to inflated

??????// *? INFLATING??? - busy wait for conversion to complete

??????// *? Neutral????? - aggressively inflate the object.

??????// *? BIASED?????? - Illegal.? We should never see this

???

??????// CASE: inflated已膨脹，即重量級鎖

??????if?(mark->has_monitor()) {//判斷當前是否為重量級鎖

??????????ObjectMonitor * inf = mark->monitor() ;//獲取指向ObjectMonitor的指針

??????????assert?(inf->header()->is_neutral(),?"invariant");

??????????assert?(inf->object() == object,?"invariant") ;

??????????assert?(ObjectSynchronizer::verify_objmon_isinpool(inf),?"monitor is invalid");

??????????return?inf ;

??????}

???

??????// CASE: inflation in progress - inflating over a stack-lock.膨脹等待（其他線程正在從輕量級鎖轉為膨脹鎖）

??????// Some other thread is converting from stack-locked to inflated.

??????// Only that thread can complete inflation -- other threads must wait.

??????// The INFLATING value is transient.

??????// Currently, we spin/yield/park and poll the markword, waiting for inflation to finish.

??????// We could always eliminate polling by parking the thread on some auxiliary list.

??????if?(mark == markOopDesc::INFLATING()) {

?????????TEVENT (Inflate: spin?while?INFLATING) ;

?????????ReadStableMark(object) ;

?????????continue?;

??????}

???

??????// CASE: stack-locked棧鎖（輕量級鎖）

??????// Could be stack-locked either by this thread or by some other thread.

??????//

??????// Note that we allocate the objectmonitor speculatively, _before_ attempting

??????// to install INFLATING into the mark word.? We originally installed INFLATING,

??????// allocated the objectmonitor, and then finally STed the address of the

??????// objectmonitor into the mark.? This was correct, but artificially lengthened

??????// the interval in which INFLATED appeared in the mark, thus increasing

??????// the odds of inflation contention.

??????//

??????// We now use per-thread private objectmonitor free lists.

??????// These list are reprovisioned from the global free list outside the

??????// critical INFLATING...ST interval.? A thread can transfer

??????// multiple objectmonitors en-mass from the global free list to its local free list.

??????// This reduces coherency traffic and lock contention on the global free list.

??????// Using such local free lists, it doesn't matter if the omAlloc() call appears

??????// before or after the CAS(INFLATING) operation.

??????// See the comments in omAlloc().

??

??????if?(mark->has_locker()) {

??????????ObjectMonitor * m = omAlloc (Self) ;//獲取一個可用的ObjectMonitor

??????????// Optimistically prepare the objectmonitor - anticipate successful CAS

??????????// We do this before the CAS in order to minimize the length of time

??????????// in which INFLATING appears in the mark.

??????????m->Recycle();

??????????m->_Responsible? = NULL ;

??????????m->OwnerIsThread = 0 ;

??????????m->_recursions?? = 0 ;

??????????m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;???// Consider: maintain by type/class

???

??????????markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;

??????????if?(cmp != mark) {//CAS失敗//CAS失敗，說明沖突了，自旋等待//CAS失敗，說明沖突了，自旋等待//CAS失敗，說明沖突了，自旋等待

?????????????omRelease (Self, m,?true) ;//釋放監視器鎖

?????????????continue?;???????// Interference -- just retry

??????????}

??

??????????// We've successfully installed INFLATING (0) into the mark-word.

??????????// This is the only case where 0 will appear in a mark-work.

??????????// Only the singular thread that successfully swings the mark-word

??????????// to 0 can perform (or more precisely, complete) inflation.

??????????//

??????????// Why do we CAS a 0 into the mark-word instead of just CASing the

??????????// mark-word from the stack-locked value directly to the new inflated state?

??????????// Consider what happens when a thread unlocks a stack-locked object.

??????????// It attempts to use CAS to swing the displaced header value from the

??????????// on-stack basiclock back into the object header.? Recall also that the

??????????// header value (hashcode, etc) can reside in (a) the object header, or

??????????// (b) a displaced header associated with the stack-lock, or (c) a displaced

??????????// header in an objectMonitor.? The inflate() routine must copy the header

??????????// value from the basiclock on the owner's stack to the objectMonitor, all

??????????// the while preserving the hashCode stability invariants.? If the owner

??????????// decides to release the lock while the value is 0, the unlock will fail

??????????// and control will eventually pass from slow_exit() to inflate.? The owner

??????????// will then spin, waiting for the 0 value to disappear.?? Put another way,

??????????// the 0 causes the owner to stall if the owner happens to try to

??????????// drop the lock (restoring the header from the basiclock to the object)

??????????// while inflation is in-progress.? This protocol avoids races that might

??????????// would otherwise permit hashCode values to change or "flicker" for an object.

??????????// Critically, while object->mark is 0 mark->displaced_mark_helper() is stable.

??????????// 0 serves as a "BUSY" inflate-in-progress indicator

??????????// fetch the displaced mark from the owner's stack.

??????????// The owner can't die or unwind past the lock while our INFLATING

??????????// object is in the mark.? Furthermore the owner can't complete

??????????// an unlock on the object, either.

??????????markOop dmw = mark->displaced_mark_helper() ;

??????????assert?(dmw->is_neutral(),?"invariant") ;

??????????//CAS成功，設置ObjectMonitor的_header、_owner和_object等

??????????// Setup monitor fields to proper values -- prepare the monitor

??????????m->set_header(dmw) ;

?

??????????// Optimization: if the mark->locker stack address is associated

??????????// with this thread we could simply set m->_owner = Self and

??????????// m->OwnerIsThread = 1. Note that a thread can inflate an object

??????????// that it has stack-locked -- as might happen in wait() -- directly

??????????// with CAS.? That is, we can avoid the xchg-NULL .... ST idiom.

??????????m->set_owner(mark->locker());

??????????m->set_object(object);

??????????// TODO-FIXME: assert BasicLock->dhw != 0.

??

??????????// Must preserve store ordering. The monitor state must

??????????// be stable at the time of publishing the monitor address.

??????????guarantee (object->mark() == markOopDesc::INFLATING(),?"invariant") ;

??????????object->release_set_mark(markOopDesc::encode(m));

???

??????????// Hopefully the performance counters are allocated on distinct cache lines

??????????// to avoid false sharing on MP systems ...

??????????if?(ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;

??????????TEVENT(Inflate: overwrite stacklock) ;

??????????if?(TraceMonitorInflation) {

????????????if?(object->is_instance()) {

??????????????ResourceMark rm;

??????????????tty->print_cr("Inflating object "?INTPTR_FORMAT?" , mark "?INTPTR_FORMAT?" , type %s",

????????????????(void?*) object, (intptr_t) object->mark(),

????????????????object->klass()->external_name());

????????????}

??????????}

??????????return?m ;

??????}

???

??????// CASE: neutral 無鎖

??????// TODO-FIXME: for entry we currently inflate and then try to CAS _owner.

??????// If we know we're inflating for entry it's better to inflate by swinging a

??????// pre-locked objectMonitor pointer into the object header.?? A successful

??????// CAS inflates the object *and* confers ownership to the inflating thread.

??????// In the current implementation we use a 2-step mechanism where we CAS()

??????// to inflate and then CAS() again to try to swing _owner from NULL to Self.

??????// An inflateTry() method that we could call from fast_enter() and slow_enter()

??????// would be useful.

??

??????assert?(mark->is_neutral(),?"invariant");

??????ObjectMonitor * m = omAlloc (Self) ;

??????// prepare m for installation - set monitor to initial state

??????m->Recycle();

??????m->set_header(mark);

??????m->set_owner(NULL);

??????m->set_object(object);

??????m->OwnerIsThread = 1 ;

??????m->_recursions?? = 0 ;

??????m->_Responsible? = NULL ;

??????m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;???????// consider: keep metastats by type/class

???

??????if?(Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {

??????????m->set_object (NULL) ;

??????????m->set_owner? (NULL) ;

??????????m->OwnerIsThread = 0 ;

??????????m->Recycle() ;

??????????omRelease (Self, m,?true) ;

??????????m = NULL ;

??????????continue?;

??????????// interference - the markword changed - just retry.

??????????// The state-transitions are one-way, so there's no chance of

??????????// live-lock -- "Inflated" is an absorbing state.

??????}

???

??????// Hopefully the performance counters are allocated on distinct

??????// cache lines to avoid false sharing on MP systems ...

??????if?(ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;

??????TEVENT(Inflate: overwrite neutral) ;

??????if?(TraceMonitorInflation) {

????????if?(object->is_instance()) {

??????????ResourceMark rm;

??????????tty->print_cr("Inflating object "?INTPTR_FORMAT?" , mark "?INTPTR_FORMAT?" , type %s",

????????????(void?*) object, (intptr_t) object->mark(),

????????????object->klass()->external_name());

????????}

??????}

??????return?m ;

??}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

//創建一個啥都沒有的類：

public?class?TestDemo {}

??

public?class?DemoExample {

????static?TestDemo testDemo;

????public?static?void?main(String[] args)?throws?Exception {

????????//此處睡眠50000ms，取消jvm默認偏向鎖延遲4000ms

????????Thread.sleep(5000);

????????testDemo=?new?TestDemo();

??

????????//hash計算？

????????//testDemo.hashCode();

??

????????System.out.println("befor lock");

????????//無鎖：偏向鎖？

????????System.out.println(ClassLayout.parseInstance(testDemo).toPrintable());

??

????????synchronized?(testDemo){

????????????System.out.println("lock ing");

????????????System.out.println(ClassLayout.parseInstance(testDemo).toPrintable());

????????}

??

????????System.out.println("after lock");

????????System.out.println(ClassLayout.parseInstance(testDemo).toPrintable());

????}

}

1

2

3

4

5

product(intx, BiasedLockingBulkRebiasThreshold, 20,?????????????????????? \

????????"Threshold of number of revocations per type to try to "??????????\

????????"rebias all objects in the heap of that type")??????????????????? \

????????range(0, max_intx)??????????????????????????????????????????????? \

????????constraint(BiasedLockingBulkRebiasThresholdFunc,AfterErgo)??????? \

1

2

3

4

5

product(intx, BiasedLockingBulkRevokeThreshold, 40,?????????????????????? \

????????"Threshold of number of revocations per type to permanently "?????\

????????"revoke biases of all objects in the heap of that type")????????? \

????????range(0, max_intx)??????????????????????????????????????????????? \

????????constraint(BiasedLockingBulkRevokeThresholdFunc,AfterErgo)??

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

public?class?TestDemo {

}

public?class?DemoExample4 {

????public?static?void?main(String[] args)?throws?InterruptedException {

????????test1();

????}

???

???public?class?DemoExample5 {

????public?static?void?main(String[] args)?throws?InterruptedException {

????????test1();

????}

???

????/**

?????* 僅證明批量重偏向

?????* @throws InterruptedException

?????*/

????public??static??void?test1()?throws?InterruptedException {

????????List<TestDemo> list =?new?ArrayList<>();

????????for?(int?i =?0; i <?100; i++) {

????????????list.add(new?TestDemo());

????????}

????????Thread t1 =?new?Thread(()->{

????????????System.out.println("加鎖前 get(0) 應該是無鎖可偏向 "+ ClassLayout.parseInstance(list.get(0)).toPrintable());

????????????for?(TestDemo a:list? ) {

????????????????synchronized?(a){

????????????????????System.out.print("加鎖 >");

????????????????}

????????????}

????????????System.out.println();

????????????System.out.println("加鎖后 get(0) 應該是偏向鎖"+ClassLayout.parseInstance(list.get(0)).toPrintable());

????????????try?{

????????????????TimeUnit.SECONDS.sleep(1000);//這里不讓線程死，防止線程ID復用

????????????}?catch?(InterruptedException e) {

????????????????e.printStackTrace();

????????????}

????????});

????????t1.start();

????????TimeUnit.SECONDS.sleep(5);

????????Thread t2 =?new?Thread(()->{

????????????for?(int?i =?0; i <?40; i++) {

????????????????TestDemo a = list.get(i);

????????????????synchronized?(a){

????????????????????System.out.print("加鎖 >");

????????????????}

????????????????if?(i==18){

????????????????????System.out.println();

????????????????????System.out.println("加鎖后 get(18) 應該是無鎖（輕量級鎖釋放） "+ClassLayout.parseInstance(list.get(i)).toPrintable());

????????????????}

????????????????if?(i==19){?//開始重偏向

????????????????????System.out.println();

????????????????????System.out.println("加鎖后 get(19) 應該是偏向鎖 "+ClassLayout.parseInstance(list.get(i)).toPrintable());

????????????????????System.out.println("加鎖后 get(0) 應該是無鎖（輕量級鎖釋放） "+ClassLayout.parseInstance(list.get(0)).toPrintable());

????????????????????System.out.println("加鎖后 get(99) 應該是偏向鎖 偏向t1 "+ClassLayout.parseInstance(list.get(99)).toPrintable());

????????????????}

????????????????if?(i==20){

????????????????????System.out.println();

????????????????????System.out.println("加鎖后 get(20) 應該是偏向鎖 "+ClassLayout.parseInstance(list.get(i)).toPrintable());

????????????????}

????????????}

????????});

????????t2.start();

????}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

public?class?TestDemo {

}

public?class?DemoExample7 {

????public?static?void?main(String[] args)?throws?Exception {

??

????????List<TestDemo> list =?new?ArrayList<>();

????????//初始化數據

????????for?(int?i =?0; i <?100; i++) {

????????????list.add(new?TestDemo());

????????}

???

????????Thread t1 =?new?Thread() {

????????????String name =?"1";

????????????public?void?run() {

????????????????System.out.printf(name);

????????????????for?(TestDemo a : list) {

????????????????????synchronized?(a) {

????????????????????????if?(a == list.get(10)) {

????????????????????????????System.out.println("t1 預期是偏向鎖"?+?10?+ ClassLayout.parseInstance(a).toPrintable());

????????????????????????}

????????????????????}

????????????????}

????????????????try?{

????????????????????Thread.sleep(100000);

????????????????}?catch?(InterruptedException e) {

????????????????????e.printStackTrace();

????????????????}

????????????}

????????};

????????t1.start();

????????Thread.sleep(5000);

????????System.out.println("main 預期是偏向鎖"?+?10?+ ClassLayout.parseInstance(list.get(10)).toPrintable());

???

????????Thread t2 =?new?Thread() {

????????????String name =?"2";

??

????????????public?void?run() {

????????????????System.out.printf(name);

????????????????for?(int?i =?0; i <?100; i++) {

????????????????????TestDemo a = list.get(i);

????????????????????// hack 為了在批量重偏向發生后再次加鎖,前面使用了輕量級鎖的對象

????????????????????if?(i ==?20) {

????????????????????????a = list.get(9);

????????????????????}

???

????????????????????synchronized?(a) {

????????????????????????if?(i ==?10) {

????????????????????????????//已經經過偏向鎖撤銷，并使用輕量級鎖的對象，釋放后? 狀態依為001 無鎖狀態

????????????????????????????System.out.println("t2 i=10 get(1)預期是無鎖"?+ ClassLayout.parseInstance(list.get(1)).toPrintable());

????????????????????????????//因為和t1交替使用對象a 沒有發生競爭，但偏向鎖已偏向，另外不滿足重偏向條件，所以使用輕量級鎖

????????????????????????????System.out.println("t2 i=10 get(i) 預期輕量級鎖 "?+ i + ClassLayout.parseInstance(a).toPrintable());

????????????????????????}

????????????????????????if?(i ==?19) {

????????????????????????????//已經經過偏向鎖撤銷，并使用輕量級鎖的對象，在批量重偏向發生后。不會影響現有的狀態? 狀態依然為001

????????????????????????????System.out.println("t2? i=19? get(10)預期是無鎖"?+?10?+ ClassLayout.parseInstance(list.get(10)).toPrintable());

????????????????????????????//滿足重偏向條件后，已偏向的對象可以重新使用偏向鎖 將線程id指向當前線程，101

????????????????????????????System.out.println("t2? i=19? get(i) 滿足重偏向條件20 預期偏向鎖 "?+ i + ClassLayout.parseInstance(a).toPrintable());

????????????????????????????//滿足重偏向條件后，已偏向還為需要加鎖的對象依然偏向線程1 因為偏向鎖的撤銷是發生在下次加鎖的時候。這里沒有執行到同步此對象，所以依然偏向t1

????????????????????????????System.out.println("t2? i=19? get(i) 滿足重偏向條件20 但后面的對象沒有被加鎖，所以依舊偏向t1 "?+ i + ClassLayout.parseInstance(list.get(40)).toPrintable());

????????????????????????}

????????????????????????if?(i ==?20) {

????????????????????????????//滿足重偏向條件后，再次加鎖之前使用了輕量級鎖的對象，依然輕量級鎖，證明重偏向這個狀態只針對偏向鎖。已經發生鎖升級的，不會退回到偏向鎖

????????????????????????????System.out.println("t2? i=20 滿足偏向條件之后，之前被設置為無鎖狀態的對象，不可偏向，這里使用的是輕量級鎖? get(9)預期是輕量級鎖 "?+ ClassLayout.parseInstance(a).toPrintable());

????????????????????????}

????????????????????}

????????????????}

????????????????try?{

????????????????????Thread.sleep(100000);

????????????????}?catch?(InterruptedException e) {

????????????????????e.printStackTrace();

????????????????}

????????????}

????????};

????????t2.start();

????????Thread.sleep(5000);

????}

}