java并发（二十八）并发随机数,原子变量,并发集合

[size=xx-large]原子变量[/size]
java.util.concurrent.atomic包定义了对单一变量进行原子操作的类。原子变量类提供了在整数或者对象引用上的细粒度原子操作（因此可伸缩性更高），并使用了现代处理器中提供的底层并发原语（例如比较并交换[compare-and-swap]）。所有的类都提供了get和set方法，可以使用它们像读写volatile变量一样读写原子类。就是说，同一变量上的一个set操作对于任意后续的get操作存在happens-before关系。原子的compareAndSet方法也有内存一致性特点，就像应用到整型原子变量中的简单原子算法。
为了看看这个包如何使用，让我们返回到最初用于演示线程干扰的Counter类：

public class Counter {
	private int c = 0;

	public void increment() {
		c++;
	}

	public void decrement() {
		c--;
	}

	public int value() {
		return c;
	}
}

使用同步是一种使Counter类变得线程安全的方法，如SynchronizedCounter：

public class SynchronizedCounter {
	private int c = 0;

	public synchronized void increment() {
		c++;
	}

	public synchronized void decrement() {
		c--;
	}

	public synchronized int value() {
		return c;
	}
}

对于这个简单的类，同步是一种可接受的解决方案。但是对于更复杂的类，我们可能想要避免不必要同步所带来的活跃度影响。将int替换为AtomicInteger允许我们在不进行同步的情况下阻止线程干扰，如AtomicCounter：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
	private AtomicInteger c = new AtomicInteger(0);

	public void increment() {
		c.incrementAndGet();
	}

	public void decrement() {
		c.decrementAndGet();
	}

	public int value() {
		return c.get();
	}
}

[size=xx-large]并发集合[/size]
[b]ConcurrentHashMap[/b]
使用的是一种更细粒度的锁，这种机制称为分段锁（Lock Striping）。在这种机制中，任意数量的读取线程可以并发的访问Map，执行读取操作的线程和执行写入操作的线程可以并发地访问Map，并且一定数量的写入线程可以并发地修改Map。
迭代的时候不会抛出ConcurrentModificationException，迭代器是拥有"弱一致性"，而非"即时失败。size返回的是一个估计值。
ConcurrentNavigableMap是ConcurrentMap的子接口，支持近似匹配。ConcurrentNavigableMap的标准实现是ConcurrentSkipListMap，它是TreeMap的并发模式。ConcurrentSkipListMap和ConcurrentSkipListSet分别作为同步的SortedMap和SortedSet的并发替代品。

import java.util.Map;

public interface ConcurrentMap<K, V> extends Map<K, V> {

    /**
     * 仅当K没有相应的映射值才插入
     * @param key
     * @param value
     * @return
     */
    V putIfAbsent(K key, V value);

    /**
     * 仅当K被映射到V时才移除
     * @param key
     * @param value
     * @return
     */
    boolean remove(Object key, Object value);

    /**
     * 仅当 K被映射到oldValue时才替换为newValue
     * @param key
     * @param oldValue
     * @param newValue
     * @return
     */
    boolean replace(K key, V oldValue, V newValue);

    /**
     * 仅当K被映射到某个值时才替换为newValue
     * @param key
     * @param value
     * @return
     */
    V replace(K key, V value);
}

[b]CopyOnWriteArrayList[/b]
在每次修改时，都会创建并重新发布一个新的容器副本，从而实现复制。“写入时复制”返回迭代器不会抛出ConcurrentModificationException，并且返回的元素与迭代器创建时的元素完全一致，而不必考虑之后修改操作所带来的影响。

[size=xx-large]并发随机数[/size]
在JDK7中，java.util.concurrent包含了一个相当便利的类，ThreadLocalRandom，当应用程序期望在多个线程或ForkJoinTasks中使用随机数时。 对于并发访问，使用TheadLocalRandom代替Math.random()可以减少竞争，从而获得更好的性能。 你只需调用ThreadLocalRandom.current()， 然后调用它的其中一个方法去获取一个随机数即可。下面是一个例子：

int r = ThreadLocalRandom.current().nextInt(4,77);