黑马程序员_并发库的应用

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

定时器Timer应用：Timer.schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。delay的单位为秒。举例说明：

class  TimerTest
{
	public static void main(String[] args) {
	//TimerTask是一个实现了Runnable接口的抽象类所以需要实现run方法
	new Timer().schedule(new TimerTask() {
			
			@Override
			public void run() {	//实现run方法
				System.out.println("bombing!");
				
			}
		}, 10000,3000); //延迟10s后执行run方法，之后每隔3s运行一次
	｝		
}

Java5中的线程并发库

JDK5中增加了Doug Lea的并发库，这一引进给java线程的管理和使用提供了强大的便利性。 java.util.current包中提供了对线程优化、管理的各项操作，使得线程的使用变得的心应手。该包提供了线程的运行，线程池的创建，线程生命周期的控制，线程间的协作等功能。

AtomicInteger

public class AtomicInteger
   
    extends 
    Number
   
   
    implements 
    Serializable        用原子方式更新的 
    int 值。此类确实扩展了 
    Number，允许那些处理基于数字类的工具和实用工具进行统一访问。 
   

实际上就等于是增加了线程同步使得共享的整数变得安全，当多个线程使用同一个整数变量时推荐使用这个类。这只是整型数据的例子还有其他类型数据对应的类可以查手册。

java线程池：

使用线程池的好处: 

1.减少在创建和销毁线程上所花的时间以及系统资源的开销 

2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存 

newFixedThreadPool  创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

newCachedThreadPool()
          创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

Callable&Future:

他们两一个产生结果，一个获取结果。 Callable接口类似于Runnable；但是Runnable不会返回结果，并且无法抛出返回结果的异常。而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值。

Lock&Condition实现线程同步通信：

Lock比传统线程模型中的Synchronied方式更加面向对象，Lock锁本身也是一个对象。同一个锁被锁上之后除非使用其他锁否则其他线程无法用同一把锁进入被锁的代码块，直到上锁的线程释放这把锁。示例代码：

	static class Outputer{
		//Lock是个接口不可以new只能new它的实现子类这里是ReentrantLock
		Lock lock = new ReentrantLock();
		public void output(String name){
			int len = name.length();
			//上锁
			lock.lock();
			//如果程序在输出语句过程中异常，那么就无法释放锁
			//所以这里使用try无论是否异常都必须释放锁
			try{
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}finally{
				//释放锁
				lock.unlock();
			}
		}

读写锁：多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是有JVM控制，程序员只需要上锁就行了。

Condition:功能类似于传统线程技术中的wait和notify的功能，可以说condition代替了wait和notify，Condition的优势是支持多路等待，就是我可以定义多个Condition，每个condition控制线程的一条执行通路。传统方式只能是一路等待。

	static class Business {
			Lock lock = new ReentrantLock();
			//通过lock锁新建一个condition对象
			Condition condition = lock.newCondition();
		  private boolean bShouldSub = true;
		  public  void sub(int i){
			  lock.lock();
			  try{
				  while(!bShouldSub){
					  try {
						//等待其他线程的signal信号
						condition.await();
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				  }
					for(int j=1;j<=10;j++){
						System.out.println("sub thread sequence of " + j + ",loop of " + i);
					}
				  bShouldSub = false;
				  //给其他等待的线程发送signal唤醒信号
				  condition.signal();
			  }finally{
				  lock.unlock();
			  }
		  }

Semaphore信号量：可以维护当前访问自身的线程个数，并提供同步机制，简单的说就是可以控制某个资源可以同时被多少个线程访问。正在等待中的线程可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。

下面的代码示例了10个线程要访问一个由信号量限制为3的情况：

public class SemaphoreTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		//定义Semaphore信号量对象限制最多只能三个线程访问
		final  Semaphore sp = new Semaphore(3);
		//每次循环建立一个线程，循环10次
		for(int i=0;i<10;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						//获得限制的许可，当超过限制量会获取失败
						sp.acquire();
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
					try {
						Thread.sleep((long)(Math.random()*10000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"即将离开");					
					//释放许可
					sp.release();
					//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
					System.out.println("线程" + Thread.currentThread().getName() + 
							"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");					
				}
			};
			service.execute(runnable);			
		}
}

CyclicBarrier：一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。简单的说就是必须等待所有的线程都准备好了之后然后再开始执行。

CountDownLatch：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化CountDownLatch。形象的说就是一个计时器，由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞，当计时器跳到0时受await阻塞的线程才开始执行。

Exchanger:用于线程之间彼此交换数据。

java5并发库的集合：可阻塞的队列

队列包含固定长度的队列和不固定 长度的队列：

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable

一个由数组支持的有界阻塞队列；此类实现BlockingQueue接口 

BlockingQueue接口方法以一下四种形式出现：抛出异常，特殊值，阻塞，超时。

	抛出异常	特殊值	阻塞
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

同步集合：

常用的集合类ArrayList、Map等在多线程操作同一对象时会发生不同步的线程而造成数据读取和写入错误；

通常都是采用synchronized修饰符或Lock将那些方法括起来来确保它们在执行时不会被其他线程打扰；

java5线程并发库为我们提供了一些相对于普通集合类的线程安全类，来自动解决线程同步的问题，

如ConcurrentHashMap、ConcurrentSkipListMap、CopyOnWriteArrayList等。