JAVA 多线程编程之一（基础）

1.原子变量（java.util.concurrent.atomic)

　　原子状态，变化不会被打断，如 AtomicLong , AtomicInteger

2.内部锁 synchronized 块

　　synchronized方法的锁就是方法所在的对象本身，可重入

3.共享变量

　　Volatile变量，每次从内存取出数据，可以获得最新的副本。

　　没有同步情况下的共享变量，可能执行顺序不是按照代码的组织，

　　

public  class NoVisibility{
private static boolean ready;
private static int number;

private static class ReaderThread extends Thread{
public void run(){
while(!ready){
Thread.yield();
}
System.out.println(number);
}
}

public static void main(String args[]){
new ReaderThread().start();
number = 42;
ready =  true;
}

　　栈限制，把本地的引用类型限制在本地线程中，不溢出

　　不可变对象永远是线程安全的

4.ThreadLocal 允许线程和自己的变量保存在一起

　　向已有的线程安全类添加功能，

　　

public class BetterVector<E> extends Vector<E>{
public synchronized boolean putIfAbsent(E x){
...
}
}

但是下面这种方式不是线程安全的：

public class ListHelper<E>{
public List<E> list = Collections.synchronizedList(new ArrayList<E>());

public synchronized boolean putIfAbsent(E x){
...
}
}

因为synchronized关键字锁住的是 ListHelpder类，所以并没有获得List的锁，那么在putIfAbsent中修改List时，是不能保证

其它方法不对list修改。

下面的方法才是正确的：

public class ListHelper<E>{
public List<E> list = Collections.synchronizedList(new ArrayList<E>());

public  boolean putIfAbsent(E x){
synchronized(list);
...
}
}

或者是使用组合实现List接口，这样第一种方式就是正确的，因为获得了正确的锁。

5. 同步容器

Java 5.0 提供了并发容器来替换同步容器，提高并发的效率。 ConcurrentHashMap代替SynchronizedMap

FutureTask 通过Callable 实现，可以理解为是一个可携带结果的Runnable

semaphore 信号量，控制对资源的访问数量限制

Barrier 提供一种可以一次执行多个线程，直到所有的线程都完成才继续进行，有任何一个线程没有完成，所有

完成的现成都要等待这个线程完成

一个正确的多线程访问的缓存的写法

package net.jcip.examples;

import java.util.concurrent.*;

/**
* Memoizer
* <p/>
* Final implementation of Memoizer
*
* @author Brian Goetz and Tim Peierls
*/
public class Memoizer <A, V> implements Computable<A, V> {
private final ConcurrentMap<A, Future<V>> cache
= new ConcurrentHashMap<A, Future<V>>();
private final Computable<A, V> c;

public Memoizer(Computable<A, V> c) {
this.c = c;
}

public V compute(final A arg) throws InterruptedException {
while (true) {
Future<V> f = cache.get(arg);
if (f == null) {
Callable<V> eval = new Callable<V>() {
public V call() throws InterruptedException {
return c.compute(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f = cache.putIfAbsent(arg, ft);
if (f == null) {
f = ft;
ft.run();
}
}
try {
return f.get();
} catch (CancellationException e) {
cache.remove(arg, f);
} catch (ExecutionException e) {
throw LaunderThrowable.launderThrowable(e.getCause());
}
}
}
}