java8.util.concurrent.package-info Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of streamsupport-atomic Show documentation

streamsupport-atomic is a backport of the java.util.concurrent.atomic classes added in Java 8 (Double/Long Accumulator/Adder) for Java 6 / 7 and Android developers

There is a newer version: 1.7.4

Show newest version

/*
 * Copyright (c) 2012, 2013, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

/**
 * Some of the Java 7 and Java 8 utility classes commonly used in concurrent programming.
 * 
 * Memory Consistency Properties
 *
 * 
 * Chapter 17 of
 * The Java™ Language Specification defines the
 * happens-before relation on memory operations such as reads and
 * writes of shared variables.  The results of a write by one thread are
 * guaranteed to be visible to a read by another thread only if the write
 * operation happens-before the read operation.  The
 * {@code synchronized} and {@code volatile} constructs, as well as the
 * {@code Thread.start()} and {@code Thread.join()} methods, can form
 * happens-before relationships.  In particular:
 *
 * 
 *   Each action in a thread happens-before every action in that
 *   thread that comes later in the program's order.
 *
 *   
An unlock ({@code synchronized} block or method exit) of a
 *   monitor happens-before every subsequent lock ({@code synchronized}
 *   block or method entry) of that same monitor.  And because
 *   the happens-before relation is transitive, all actions
 *   of a thread prior to unlocking happen-before all actions
 *   subsequent to any thread locking that monitor.
 *
 *   
A write to a {@code volatile} field happens-before every
 *   subsequent read of that same field.  Writes and reads of
 *   {@code volatile} fields have similar memory consistency effects
 *   as entering and exiting monitors, but do not entail
 *   mutual exclusion locking.
 *
 *   
A call to {@code start} on a thread happens-before any
 *   action in the started thread.
 *
 *   
All actions in a thread happen-before any other thread
 *   successfully returns from a {@code join} on that thread.
 *
 * 
 * 
 * @since 1.8
 */
package java8.util.concurrent;