java5引入的并发编程库
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