本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！
在阅读《Thinking in Java》的过程中，并发这一章出现不少新特性，工作中也有遇到，就详细介绍一下
Java5出现一个新的对象AutomicInteger，经查询它是为避免线程不安全而出现，避免传统方法里使用finally加锁的情况，在高并发环境下应用比较常见！
用法如下：
public static void main(String[] args) {
AtomicInteger ai = new AtomicInteger(0);
print("当前值：" + ai.get());// 取得当前值
print("给当前值加2，返回更新后的值：" + ai.addAndGet(2));// 给当前值加2，返回更新后的值
print("当前值：" + ai.get());// 取得当前值
print(" 减1操作，返回更新后的值：" + ai.decrementAndGet());// 减1操作，返回更新后的值
print("当前值：" + ai.get());// 取得当前值
print(" 给当前值加2，返回当前的值：" + ai.getAndAdd(2));// 给当前值加2，返回当前的值
print("当前值：" + ai.get());// 取得当前值
print("减1操作， 返回操作前的值：" + ai.getAndDecrement());//减1操作， 返回操作前的值
print("当前值：" + ai.get());// 取得当前值
print("加1操作，返回操作前的值：" + ai.getAndIncrement());// 加1操作，返回操作前的值
print("当前值：" + ai.get());// 取得当前值
print(" 设置新值，返回操作前的值：" + ai.getAndSet(2));// 设置新值，返回操作前的值
print("当前值：" + ai.get());// 取得当前值
print("加1操作，返回更新后的值：" + ai.incrementAndGet());// 加1操作，返回更新后的值
System.out.println(ai.compareAndSet(2, 3));
System.out.println((ai.weakCompareAndSet(2, 3)));
ai.lazySet(13);// 设置新值
print("当前值：" + ai.get());// 取得当前值
}
static void print(String str) {
System.out.println(str);
}结果如下：
当前值：0 给当前值加2，返回更新后的值：2 当前值：2 减1操作，返回更新后的值：1 当前值：1 给当前值加2，返回当前的值：1 当前值：3 减1操作， 返回操作前的值：3 当前值：2 加1操作，返回操作前的值：2 当前值：3 设置新值，返回操作前的值：3 当前值：2 加1操作，返回更新后的值：3 false false 当前值：13
Java5中一个新的特性：volatile，主要也是用来实现并发，特点：如果值改变，则告诉所有调用对象
示例：
public class LatestModify extends Thread {
volatile boolean mRun = true;
public void test() {
try {
Thread.sleep(2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
mRun = false;
}
@Override
public void run() {
// TODO Auto-generated method stub
super.run();
while (mRun) {
System.out.println("我跑跑！");
}
System.out.println("我不跑了！");
}
public static void main(String[] args) throws InstantiationException,
IllegalAccessException {
LatestModify modify = LatestModify.class.newInstance();
modify.start();
modify.test();
}我跑跑！我跑跑！
...........
我跑跑！
我跑跑！
我跑跑！
我不跑了！
Java7中新特性Semaphore允许多个任务同时访问一个资源
原理：给一个资源若干“许可证”，分发给每个任务
应用场景：不详
class Pool<T>{
private int size;
private List<T> items=new ArrayList<T>();
private volatile boolean[] checkedOut;
private Semaphore available;
public Pool(Class<T> classObject,int size){
this.size=size;
checkedOut=new boolean[size];
available=new Semaphore(size, true);
for (int i = 0; i < size; i++) {
try {
items.add(classObject.newInstance());
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public T checkOut() throws InterruptedException{
available.acquire();
return getItem();
}
public void checkIn(T x){
if(releaseItem(x)){
available.release();
}
}
private synchronized T getItem(){
for (int i = 0; i < size; i++) {
if(!checkedOut[i]){
checkedOut[i]=true;
return items.get(i);
}
}
return null;
}
private synchronized boolean releaseItem(T item){
int index=items.indexOf(item);
if(index==-1)
return false;
if(checkedOut[index]){
checkedOut[index]=false;
return true;
}
return false;
}
}因此加上这两个关键字volatile和Semphore，加上sychronzied关键字对象加锁、对方法加锁、Lock、wait+notify、Sleep总共有7个方法，进行多线程同步即并发操作