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
|
/*
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.util.Calendar;
import java.util.Locale;
import java.util.SimpleTimeZone;
import java.util.TimeZone;
import java.util.function.Supplier;
/*
* @test
* @bug 8191216
* @summary test that provokes race between cloning and lazily initializing
* SimpleTimeZone cache fields
*/
public class SimpleTimeZoneCloneRaceTest {
public static void main(String[] args) throws InterruptedException {
// shared TZ user repeatedly samples sharedTZ and calculates offset
// using the shared instance
TimeZoneUser sharedTZuser = new TimeZoneUser(() -> sharedTZ);
// cloned TZ user repeatedly samples sharedTZ then clones it and
// calculates offset using the clone...
TimeZoneUser clonedTZuser = new TimeZoneUser(() -> {
// sample shared TZ
TimeZone tz = sharedTZ;
// do some computation that takes roughly the same time as it takes
// sharedTZUser to start changing cache fields in shared TZ
cpuHogTZ.getOffset(time);
// now clone the sampled TZ and return it, hoping the clone is done
// at about the right time....
return (TimeZone) tz.clone();
});
// start threads
Thread t1 = new Thread(sharedTZuser);
Thread t2 = new Thread(clonedTZuser);
t1.start();
t2.start();
// plant new SimpleTimeZone instances for 2 seconds
long t0 = System.currentTimeMillis();
do {
TimeZone tz1 = createSTZ();
TimeZone tz2 = createSTZ();
cpuHogTZ = tz1;
sharedTZ = tz2;
} while (System.currentTimeMillis() - t0 < 2000L);
sharedTZuser.stop = true;
clonedTZuser.stop = true;
t1.join();
t2.join();
System.out.println(
String.format("shared TZ: %d correct, %d incorrect calculations",
sharedTZuser.correctCount, sharedTZuser.incorrectCount)
);
System.out.println(
String.format("cloned TZ: %d correct, %d incorrect calculations",
clonedTZuser.correctCount, clonedTZuser.incorrectCount)
);
if (clonedTZuser.incorrectCount > 0) {
throw new RuntimeException(clonedTZuser.incorrectCount +
" fatal data races detected");
}
}
static SimpleTimeZone createSTZ() {
return new SimpleTimeZone(-28800000,
"America/Los_Angeles",
Calendar.APRIL, 1, -Calendar.SUNDAY,
7200000,
Calendar.OCTOBER, -1, Calendar.SUNDAY,
7200000,
3600000);
}
static volatile TimeZone cpuHogTZ = createSTZ();
static volatile TimeZone sharedTZ = createSTZ();
static final long time;
static final long correctOffset;
static {
TimeZone tz = createSTZ();
Calendar cal = Calendar.getInstance(tz, Locale.ROOT);
cal.set(2000, Calendar.MAY, 1, 0, 0, 0);
time = cal.getTimeInMillis();
correctOffset = tz.getOffset(time);
}
static class TimeZoneUser implements Runnable {
private final Supplier<? extends TimeZone> tzSupplier;
TimeZoneUser(Supplier<? extends TimeZone> tzSupplier) {
this.tzSupplier = tzSupplier;
}
volatile boolean stop;
int correctCount, incorrectCount;
@Override
public void run() {
while (!stop) {
TimeZone tz = tzSupplier.get();
int offset = tz.getOffset(time);
if (offset == correctOffset) {
correctCount++;
} else {
incorrectCount++;
}
}
}
}
}
|
