java5之后引入了java.util.concurrent包，专门用于解决java多线程问题。
AtomicInteger用于解决原子性操作（i++,i--的问题）：
AtomicInteger age=100;//必须定义在类的成员变量中，这样多个线程才能共同操作。如果定义在类的方法中作为局部变量，那么将存在于java虚拟机栈中，各个线程操作的是不同的变量，就不存在同步的问题。
Executors是并发编程库中的工具类，用于创建线程池：
ExecutorService threadPool=Executors.newFixedThreadPool(3);创建一个固定大小为3的线程池
Executors.newCachedThreadPool();创建一个缓存线程池，有多少任务就创建多少个线程
Executors.newSingleThreadExecutor();创建一个唯一的单线程
ExecutorService继承自Executor接口，所以具有execute(Runnable command)方法
threadPool.execute(new Runnable(){
public void run(){
//执行任务的代码
}
});
-------------------------------------------------------------------------------
//提交的是一个任务（Callable：可调用的任务）,可以得到返回的结果
Future<T> future=threadPool.submit(new Callable<T>(){
pulbic <T> call()throws Exception{
//执行任务的代码
}
});
future.get()得到线程执行完后的结果
-------------------------------------------------------------------------------
java5之后，不再使用synchronized关键字，而是使用锁对象对代码进行加锁。
Lock lock=new ReentrantLock();
(ReentrantLock顾名思义就是锁可以重入，一个线程持有锁，state=1,如果它再次调用lock方法，那么他将继续拥有这把锁，state=2.当前可重入锁要完全释放，调用了多少次lock方法，还得调用等量的unlock方法来完全释放锁)
lock.lock();对代码块加锁
try{
....//执行相关代码
}finally{
lock.unlock();释放锁
}
为什么要使用try...finally...语句呢？如果代码块抛出异常，那么程序将直接跳出并返回到被调用的上一级模块，而锁却一直没有被释放。
---------------------------------------------------------------------------------
读写锁：分为读锁和写锁。读锁与读锁不互斥（同个线程可以同时读一个数据），读锁与写锁互斥，写锁与写锁互斥（在读的时候不能写，在写的时候也不能写）
ReadWriteLock lock=new ReentrantReadWriteLock();//可重入的读写锁
lock.readLock().lock();//lock对象首先获得读锁，然后对代码进行加锁
lock.readLock().unlock();释放读锁
lock.writeLock().lock();//lock对象首先获得写锁，然后对代码进行加锁
lock.writeLock().unlock();释放写锁
缓存：
CachedData缓存数据：
多个线程可以同时访问缓存中的数据，并加上读锁，当某个线程发现里面没有数据的时候，需要往里面写数据，这时就需要挂上写锁，通知其他线程，此时不能进来读数据。以下代码为缓存的伪代码实现（只要能够写出伪代码，就能够写出程序了）：
Map<String,Object> cachedData=new HashMap<String,Object>();
ReadWriteLock lock=new ReentrantReadWriteLock();
public Object getData(String key){
lock.readLock().lock();
Object value=cachedData.get(key);
if(value==null){
lock.readLock().unlock();
lock.writeLock().lock();
value="aaa";//实际代码为：从数据库中查找
lock.writeLock().unlock();
lock.ReadLock().lock();
}
lock.readLock().unlock();
return value;
}
----------------------------------------------------------------------------------------------------------------
java5的Lock用于解决线程互斥的问题，线程同步的问题则用Condition来解决，其作用类似于传统的wait()和notify()方法。
线程要同步（我做完了某件事之后再通知你做），必须要先互斥才行，所以首先得获取锁对象并上锁：
Lock lock=new ReentrantLock();
Condition condition=lock.newConditon();
boolean flag=true;
if(!flag){ //此处最好使用while，防止虚假唤醒
//只有当flag为true时才执行相关操作，否则需要等待
condition.await();
}
......//执行代码
condition.signal();//唤醒其他线程
lock.unlock();//并且释放锁
------------------------------------------------------------------------------------------------------------------
Condition较wait()、notify()的优势在于：一个锁内部可以有多个Condition对象，能够实现多路等待和通知。
阻塞队列的实现：
Lock lock=new ReentrantLock();
Condition notFull=lock.newConditon();
Condition notEmpty=lock.newCondition();
Object[] items=new Object[100];//阻塞队列的容量为100
int count=0;//记录当前阻塞队列中对象的个数
int putptr=0;//记录放数组的指针
int takeptr=0;//记录取数组的指针
public void put(Object x){
lock.lock();//首先就要加一个锁，我在放对象的时候，其他线程不能放
while(count==items.length){
notFull.await();
}
items[putptr]=x;
if(++putptr==items.length){
putptr=0;//如果指针达到数组末尾，则需要重新回到0的位置
}
++count;
notEmpty.signal();//唤醒另外一把取锁
lock.unlock();
}
public Object take(){
lock.lock();//当我在取对象的时候，其他线程是不能够取的
while（count==0）{
notEmpt.await();
}
Object x=items[takeptr];
if(++takeptr==items.length){
takeptr=0;
}
count--；
notFull.signal();//唤醒另外一把放锁
}
--------------------------------------------------------------------------------------------------------
Semaphore信号灯（线程同步的工具类）：必须获得某段代码的信号灯，线程才能够执行该段代码，执行完之后需要释放信号灯，供其他线程竞争。如果只有一盏信号灯，可以实现互斥锁的功能（即厕所只有一个坑），如果有3盏信号灯，即代表有3个厕所坑，4个线程来访问的话，只能同时进入3个，还有一个需要在外面等待。
Semaphore sp=new Semaphore(3);
for(int i=0;i<4;i++){//有四个线程，但是每个对象执行前都必须要获得信号灯
new Thread(new Runnable(){
void run(){
sp.acquire();//线程首先需要获得信号灯，如果没有获得到，则挂起，暂时不往下执行
.....//执行相关代码
sp.release();//执行完之后，线程需要释放信号灯
}
}).start();
}
---------------------------------------------------------------------------------------------------------------
ArrayBlockingQueue 阻塞队列（以数组方式实现），实现了BlockingQueue接口：put() 和take()方法具有阻塞功能
LinkedBlockingQueue阻塞队列，以链表方式实现，大小不固定
同步集合：
如果HashMap被多个线程同时访问，则会导致线程不安全，这时就需要使用ConcurrentHashMap
ArrayList也是线程不安全的，但使用Iterator迭代的时候不能修改容器中的元素，这时需要用到CopyOnWriteArrayList