This document provides an overview of the Java Memory Model (JMM). It begins by explaining why developers should learn about the JMM and covers key concepts like program order, sequential consistency, synchronization actions, synchronization order, happens-before relationships, and double checked locking. The document uses examples and diagrams to illustrate these concepts and how the JMM handles issues like visibility and atomicity in multithreaded programs. It aims to explain the essential aspects of the JMM in an accessible way for developers.

1. Java Memory Model
for mortals
Nikolas Papirniy

2. Java and c++ developers
Java dev: May I…...
C++ dev: DEPENDS ON
IMPLEMENTATION!
Java dev: Wait, I didn’t ask a
question

3. Why should I spend time on JMM?

4. Why should I spend time on JMM?
It’s getting asked on job interviews!

5. Why should I spend time on JMM

6. Why not everyone knows JMM?

7. JMM is important!

8. Today’s goal!

9. Agenda?
1. Program Order
2. Memory Model
3. Sequential Consistency
4. Synchronization action
5. Synchronization order
6. Synchronezed with
7. Happens-before
8. Double checked locking

10. Baruch about concurrency
In this case, you can shoot
yourself in any limb of any
caliber!

11. Is it about Shipilev?
Java Memory Model Pragmatics

12. There is a little problem

13. Who visit Shipilev’s presentations?
1) Those who don’t understand Shipilev
2) Those who think they understand Shipilev
3) Shipilev

14. What was before JMM?

15. Single threaded
1. int a = 2;
2. int b = 2;
3. int c = a + b
4. System.out.println(c);
Program Order
?

16. Single threaded

17. What have we learned?
1. Program order

18. What about now?

19. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
?

20. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v

21. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v
B
v = 20;
v = 10;
print v

22. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v
B
v = 20;
v = 10;
print v
C
v = 20;
print v
v = 10

23. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v
B
v = 20;
v = 10;
print v
C
v = 20;
print v
v = 10
D
print v
v = 20;
v = 10

24. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v
B
v = 20;
v = 10;
print v
C
v = 20;
print v
v = 10
D
print v
v = 20;
v = 10

25. WAT?

26. Situation….
1. Compiler
2. Runtime
3. Hardware

27. Hello memory model!

28. Memory model QUESTION
What will you see in a certain moment of
program execution?

29. What is Java Memory Model

30. int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
A
v = 10;
v = 20;
print v
B
v = 20;
v = 10;
print v
C
v = 20;
print v
v = 10
D
print v
v = 20;
v = 10

31. What have we learned?
1. Program order
2. Memory model

32. Sequentially consistent
(Lamport 1979)
1. Executing instructions one at a time
2. Each instruction see result of previos
instructions
3. Total order is consistent with Program Order

33. Sequentially consistent
1
5
3
4
2

34. Multi-core heaven?

35. Caches

36. Cache line
read variable
Cache 1
64 bytes
Cache line

37. Cache line
Cache 1
Cache line
Cache line

39. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency

40. SC Reality: concurrency
1
write
1
5
4
read
2

41. Data race
If:
1. Several threads access one variable
2. One thread writes
3. No synchronization

42. Data race

43. Tread 1: read A
Thread 1 Thread 2
A Shared memory

44. Tread 1: read A (cont)
Thread 1 Thread 2
A Shared memory
A

45. Tread 2: read A
Thread 1 Thread 2
A A
A Shared memory

46. Thread 1: write A
Thread 1 Thread 2
A A
A Shared memory

47. Thread 2: write A
Thread 1 Thread 2
A A
A Shared memory

48. Thread 1: memory flushes to main memory
Thread 1 Thread 2
A A
A
Shared memory

49. Thread 2: memory flushes to main memory
Thread 1 Thread 2
A A
A
Shared memory

50. Read from local variable
!
Thread 1 Thread 2
A A
A
Shared memory

51. Synchronization
read
read write
write read
write
Synchronization

52. Synchronization action
➔Read / write volatile
➔Lock / unlock monitor
➔And other

53. Read / write volatile
volatile int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
SA

54. Read / write volatile
volatile int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
SA

55. Read / write volatile
volatile int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
SA

56. Read / write volatile
volatile int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
SA

57. Lock / unlock monitor
Object lock = new Object();
Thread 1 Thread 2
1a. synchronized(lock) {
2a. // actions
3a. }
1b. synchronized(lock) {
2b. // actions
3b. }
SA

58. Lock / unlock monitor
Object lock = new Object();
Thread 1 Thread 2
1a. synchronized(lock) {
2a. // actions
3a. }
1b. synchronized(lock) {
2b. // actions
3b. }
SA

59. Lock / unlock monitor
Object lock = new Object();
Thread 1 Thread 2
1a. synchronized(lock) {
2a. // actions
3a. }
1b. synchronized(lock) {
2b. // actions
3b. }
SA

60. Lock / unlock monitor
Object lock = new Object();
Thread 1 Thread 2
1a. synchronized(lock) {
2a. // actions
3a. }
1b. synchronized(lock) {
2b. // actions
3b. }
SA

61. Lock / unlock monitor
Object lock = new Object();
Thread 1 Thread 2
1a. synchronized(lock) {
2a. // actions
3a. }
1b. synchronized(lock) {
2b. // actions
3b. }
SA

62. SC Reality: visibility
int v = 0;
Thread 1 Thread 2
1a. v = 10; 1b. v = 20;
2b. System.out.println(v);
20
B
v = 20;
v = 10;
print v

63. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency
4. Synchronization action

64. Visibility of volatile variables

65. Thead 1: read A
Thread 1 Thread 2
read barrier
A Shared memory

66. Thead 1: read A (cont)
Thread 1 Thread 2
A Shared memory
A

67. Thead 2: read A
Thread 1 Thread 2
A Shared memory
A
read barrier
A

68. Thead 1: write A
Thread 1 Thread 2
A A
write barrier
A
Shared memory

69. Thead 2: write A
Thread 1 Thread 2
A A
A
Shared memory
write barrier

70. Thead 2: write A
Thread 1 Thread 2
A A
A
Shared memory
write barrier

71. Thead 1: read A
Thread 1 Thread 2
A
Shared memory
A
read barrier
A

72. SC Reality: atomicity
long v = 0L;
Thread 1 Thread 2
v = Long.MAX_VALUE; System.out.println(v);
A. Long.MAX_VALUE B. 0L
C. FFFF FFFF 0000 0000 D. 0000 0000 FFFF FFFF

73. SC Reality: atomicity
long v = 0L;
Thread 1 Thread 2
v = Long.MAX_VALUE; System.out.println(v);
A. Long.MAX_VALUE B. 0L
C. FFFF FFFF 0000 0000 D. 0000 0000 FFFF FFFF

74. SC Reality: atomicity

75. Atomicity JMM
A single write to a non-volatile long or double
value is treated as two separate writes: one to
each 32-bit half.

76. SC Reality: atomicity - SOLUTION
AtomicLong v = new AtomicLong(0L);
Thread 1 Thread 2
l.set(Long.MAX_VALUE); System.out.println(v.get());
A. Long.MAX_VALUE B. 0L
C. FFFF FFFF 0000 0000 D. 0000 0000 FFFF FFFF

77. SC Reality: atomicity - SOLUTION
AtomicLong v = new AtomicLong(0L);
Thread 1 Thread 2
l.set(Long.MAX_VALUE); System.out.println(v.get());
A. Long.MAX_VALUE B. 0L
C. FFFF FFFF 0000 0000 D. 0000 0000 FFFF FFFF

78. How?

80. Synchronization order
Thread 1 Thread 2
2 1
1
3
2
3
4 4
SA
SA
SA
SA
5 5

81. Synchronization order
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;

82. Synchronization order (1)
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;

83. Synchronization order (2)
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;

84. Synchronization order (3)
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;

85. Synchronization order (4)
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;
?

86. Synchronization order (4)
volatile int x, y;
Thread 1 Thread 2
x = 10;
int result1 = y;
y = 20;
int result2 = x;
Synchronization order consistent with Program Order

87. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency
4. Synchronization action
5. Synchronization order

88. Synchronizes with
2
1
2
3
1
3
4 4
SA
SA
Thread 1 Thread 2

89. Synchronizes-with Consistency
● volatile read - can read nearest volatile write
on SO
● monitor unlock - can release nearest monitor
lock on SO

90. Synchronizes-with
int x;
volatile int y;
Thread 1 Thread 2
x = 10;
int result1 = y;
write x: 10
read y: ? read x: ?
y = 20;
int result2 = x;
write y: 20

91. Synchronizes-with
int x;
volatile int y;
Thread 1 Thread 2
x = 10;
int result1 = y;
write x: 10
read y: ? read x: ?
y = 20;
int result2 = x;
write y: 20
SW
Write y
Read y
SW

92. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency
4. Synchronization action
5. Synchronization order
6. Synchronezed with

94. One more thing
Thread 1 Thread 2
2
1
2
3
4
1
3
4
SA
SA
5 5

95. One more thing
Thread 1 Thread 2
2
1
2
3
4
1
3
4
SA
SA
5 5
PO
PO

96. One more thing
Thread 1 Thread 2
2
1
2
3
4
1
3
4
SA
SA
5 5
PO
PO
SW

97. Happens-before!
Thread 1 Thread 2
2
1
2
3
4
1
3
4
SA
SA
5 5
PO
PO
SW

98. Happens-before
Program Order
Synchronizati
on Order
Synchronizes
With
Happens-before
Visibility

99. Happens-before for smarties
HB = {PO & SW}+

100. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency
4. Synchronization action
5. Synchronization order
6. Synchronezed with
7. Happens-before

101. Double checked locking
public static class SingletonFactory{
private Singleton instance;
public Singleton getInstance () {
if ( instance == null ) {
synchronized ( this ) {
if ( instance == null ) {
instance = new Singleton ();
}
}
}
return instance ;
}
}
public static class Singleton {
public Integer x;
public Singleton () { x = 42; }
}

102. Double checked locking
public static class SingletonFactory{
private Singleton instance;
public Singleton getInstance () {
if ( instance == null ) {
synchronized ( this ) {
if ( instance == null ) {
instance = alloc + Singleton object copy
instance.x = 42
}
}
}
return instance ;
}
}
public static class Singleton {
public Integer x;
public Singleton () { x = 42; }
}
Constructor inline

103. Double checked locking
public static class SingletonFactory{
private Singleton instance;
public Singleton getInstance () {
if ( instance == null ) {
synchronized ( this ) {
if ( instance == null ) {
instance = new Singleton ();
}
}
}
return instance ;
}
}
public static class Singleton {
public Integer x;
public Singleton () { x = 42; }
}
Returns null

105. Double checked locking
public static class SingletonFactory{
private Singleton instance;
public Singleton getInstance () {
if ( instance == null ) {
synchronized ( this ) {
if ( instance == null ) {
instance = new Singleton ();
}
}
}
return instance ;
}
}
public static class Singleton {
public Integer x;
public Singleton () { x = 42; }
}
Returns null

106. Double checked locking solution
public static class SingletonFactory{
private volatile Singleton instance;
public Singleton getInstance () {
if ( instance == null ) {
synchronized ( this ) {
if ( instance == null ) {
instance = new Singleton ();
}
}
}
return instance;
}
}
public static class Singleton {
public Integer x;
public Singleton () { x = 42; }
}

107. What have we learned?
1. Program order
2. Memory model
3. Sequential Consistency
4. Synchronization action
5. Synchronization order
6. Synchronezed with
7. Happens-before
8. Double checked locking

108. Reading