test/jdk/java/util/TimeZone/SimpleTimeZoneCloneRaceTest.java

/*
 * 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++;
                }
            }
        }
    }
}