jdk1.5的多线程总结一

Java 5.0里新加入了三个多线程包：java.util.concurrent, java.util.concurrent.atomic, java.util.concurrent.locks.
java.util.concurrent包含了常用的多线程工具，是新的多线程工具的主体。
java.util.concurrent.atomic包含了不用加锁情况下就能改变值的原子变量，比如说AtomicInteger提供了addAndGet()方法。Add和Get是两个不同的操作，为了保证别的线程不干扰，以往的做法是先锁定共享的变量，然后在锁定的范围内进行两步操作。但用AtomicInteger.addAndGet()就不用担心锁定的事了，其内部实现保证了这两步操作是在原子量级发生的，不会被别的线程干扰。
java.util.concurrent.locks 包含锁定的工具。

1.Callable 和 Future接口
新引入的Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。Callable和Runnable有几点不同：

Callable规定的方法是call()，而Runnable规定的方法是run().
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call()方法可抛出异常，而run()方法是不能抛出异常的。
运行Callable任务可拿到一个Future对象，通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
下面是一个简单的Callable例子。它实现了Callable<String>，String将是call方法的返回值类型，并且可以抛出异常。

/**
 * @author Administrator
 * 
 */
public class CallSample implements Callable<String> {

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.util.concurrent.Callable#call()
	 */
	private int aInt;

	public CallSample(int aInt) {
		this.aInt = aInt;
	}

	public String call() throws Exception {
		boolean resultOk = false;
		if (aInt == 0) {
			resultOk = true;
		} else if (aInt == 1) {
			while (true) { 
				System.out.println("looping....");
				Thread.sleep(3000);
			}
		} else {
			throw new Exception("Callable terminated with Exception!");
		}
		return resultOk?"Task done":"Task failed";
	}

}

定义一个测试程序来运行下。建立一个拥有固定3个线程的线程池，分别执行正常结束、无限循环、抛出异常这3种情况的Callable

public class Executor {
	public static void main(String[] args) {

		// 分别给定3种情况的Callable
		CallSample call1 = new CallSample(0);
		CallSample call2 = new CallSample(1);
		CallSample call3 = new CallSample(2);

		ExecutorService es = Executors.newFixedThreadPool(3);

		Future<String> future1 = es.submit(call1);
		Future<String> future2 = es.submit(call2);
		Future<String> future3 = es.submit(call3);
		try {
			System.out.println(future1.get());
			Thread.sleep(3000);
			System.out.println("Thread 2 terminated? :" + future2.cancel(true));
			System.out.println(future3.get());
		} catch (ExecutionException ex) {
			ex.printStackTrace();
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
	}
}

2.新的线程执行方式
在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提交和执行是同时进行的，如果你想对任务的执行进行调度或是控制同时执行的线程数量就需要额外编写代码来完成。5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，并且可以建立一个类似数据库连接池的线程池来执行任务。这个架构主要有三个接口和其相应的具体类组成。这三个接口是Executor, ExecutorService和ScheduledExecutorService。
Executor接口：
是用来执行Runnable任务的，它只定义一个方法：execute(Runnable command)：执行Ruannable类型的任务
ExecutorService接口：
ExecutorService继承了Executor的方法，并提供了执行Callable任务和中止任务执行的服务，其定义的方法主要有：
submit(task)：可用来提交Callable或Runnable任务，并返回代表此任务的Future对象
invokeAll(collection of tasks)：批处理任务集合，并返回一个代表这些任务的Future对象集合
shutdown()：在完成已提交的任务后关闭服务，不再接受新任务
shutdownNow()：停止所有正在执行的任务并关闭服务。
isTerminated()：测试是否所有任务都执行完毕了。
isShutdown()：测试是否该ExecutorService已被关闭.
ScheduledExecutorService接口
在ExecutorService的基础上，ScheduledExecutorService提供了按时间安排执行任务的功能，它提供的方法主要有：
schedule(task, initDelay): 安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。
scheduleAtFixedRate()：安排所提交的Runnable任务按指定的间隔重复执行.
scheduleWithFixedDelay()：安排所提交的Runnable任务在每次执行完后，等待delay所指定的时间后重复执行.

public class ScheduledExecutorServiceTest {
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		// 初始化一个ScheduledExecutorService对象，这个对象的线程池大小为2
		ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
		// 定义了一个Runnable任务。
		Runnable task1 = new Runnable() {
			public void run() {
				System.out.println("Task repeating.");
			}
		};
		/*
		 * 调用所定义的ScheduledExecutorService对象来执行任务，任务每秒执行一次。能重复执行的任务一定是Runnable类型。我们可以用TimeUnit来制定时间单位。
		 */
		final ScheduledFuture future1 = service.scheduleAtFixedRate(task1, 0,
				1, TimeUnit.SECONDS);
		//调用ScheduledExecutorService对象来执行第二个任务，第二个任务所作的就是在5秒钟后取消第一个任务
		ScheduledFuture<String> future2 = service.schedule(
				new Callable<String>() {

					public String call() {
						future1.cancel(true);
						return "task cancelled!";
					}

				}, 5, TimeUnit.SECONDS);

		System.out.println(future2.get());
		service.shutdown();
	}
}

3.Executors类
虽然以上提到的接口有其实现的具体类，但为了方便Java 5.0建议使用Executors的工具类来得到Executor接口的具体对象，需要注意的是Executors是一个类，不是Executor的复数形式。
Executors提供了以下一些static的方法：
callable(Runnable task): 将Runnable的任务转化成Callable的任务。
newSingleThreadExecutor: 产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
newCachedThreadPool(): 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行。
newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行。
newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行。

//Single Threaded ExecutorService

     ExecutorService singleThreadeService = Executors.newSingleThreadExecutor();

//Cached ExecutorService

     ExecutorService cachedService = Executors.newCachedThreadPool();

//Fixed number of ExecutorService

     ExecutorService fixedService = Executors.newFixedThreadPool(3);

//Single ScheduledExecutorService

     ScheduledExecutorService singleScheduledService = 

          Executors.newSingleThreadScheduledExecutor();

//Fixed number of ScheduledExecutorService

ScheduledExecutorService fixedScheduledService = 

     Executors.newScheduledThreadPool(3);

4.Lockers和Condition
在多线程编程里面一个重要的概念是锁定，如果一个资源是多个线程共享的，为了保证数据的完整性，在进行事务性操作时需要将共享资源锁定，这样可以保证在做事务性操作时只有一个线程能对资源进行操作，从而保证数据的完整性。在5.0以前，锁定的功能是由Synchronized关键字来实现的，这样做存在2个问题：
1.每次只能对一个对象进行锁定。若需要锁定多个对象，编程就比较麻烦，一不小心就会出现死锁现象。
2.如果线程因拿不到锁定而进入等待状况，是没有办法将其打断的。
Lock接口
ReentrantLock是Lock的具体类，Lock提供了以下一些方法：
lock(): 请求锁定，如果锁已被别的线程锁定，调用此方法的线程被阻断进入等待状态。
tryLock()：如果锁没被别的线程锁定，进入锁定状态，并返回true。若锁已被锁定，返回false，不进入等待状态。此方法还可带时间参数，如果锁在方法执行时已被锁定，线程将继续等待规定的时间，若还不行才返回false。
unlock()：取消锁定，需要注意的是Lock不会自动取消，编程时必须手动解锁。

//生成一个锁
Lock lock = new ReentrantLock();
public void accessProtectedResource() {
  lock.lock(); //取得锁定
  try {
    //对共享资源进行操作
  } finally {
    //一定记着把锁取消掉，锁本身是不会自动解锁的
    lock.unlock();
  }
}

ReadWriteLock接口
为了提高效率有些共享资源允许同时进行多个读的操作，但只允许一个写的操作，比如一个文件，只要其内容不变可以让多个线程同时读，不必做排他的锁定，排他的锁定只有在写的时候需要，以保证别的线程不会看到数据不完整的文件。ReadWriteLock可满足这种需要。ReadWriteLock内置两个Lock，一个是读的Lock，一个是写的Lock。多个线程可同时得到读的Lock，但只有一个线程能得到写的Lock，而且写的Lock被锁定后，任何线程都不能得到Lock。ReadWriteLock提供的方法有：
readLock(): 返回一个读的lock
writeLock(): 返回一个写的lock, 此lock是排他的。

public class FileOperator{
      //初始化一个ReadWriteLock
      ReadWriteLock lock = new ReentrantReadWriteLock();
public String read() { 
      //得到readLock并锁定
            Lock readLock = lock.readLock();
            readLock.lock();
            try {
                  //做读的工作
                  return "Read something";
            } finally {
                 readLock.unlock(); 
            }
      } 

public void write(String content) {
      //得到writeLock并锁定
            Lock writeLock = lock.writeLock();
            writeLock.lock();
            try {
                  //做读的工作
            } finally {
                 writeLock.unlock(); 
            }
      } 
}

虽然ReadWriteLock提供了一个高效的锁定机理，但最终程序的运行效率是和程序的设计息息相关的，比如说如果读的线程和写的线程同时在等待，要考虑是先释放读的lock还是先释放写的lock。如果写发生的频率不高，而且快，可以考虑先给写的lock。还要考虑的问题是如果一个写正在等待读完成，此时一个新的读进来，是否要给这个新的读发锁，如果释放了，可能导致写的线程等很久。

Condition接口：
有时候线程取得lock后需要在一定条件下才能做某些工作，比如说经典的Producer和Consumer问题，Consumer必须在队列里面有数据的时候才去消费数据，否则它必须暂时放弃对队列的锁定，等到Producer往队列里放了数据后再去拿来。而Producer必须等到队列有空闲了才能往里放数据，否则它也需要暂时解锁等Consumer把数据消费一些才能往队列里放数据。在Java 5.0以前，这种功能是由Object类的wait(), notify()和notifyAll()等方法实现的，在5.0里面，这些功能集中到了Condition这个接口来实现，Condition提供以下方法：
await()：使调用此方法的线程放弃锁定，进入睡眠直到被打断或被唤醒。
signal(): 唤醒一个等待的线程
signalAll()：唤醒所有等待的线程
用一个简单的吃苹果例子来看看。

public class Basket {      
Lock lock = new ReentrantLock();
//产生Condition对象
     Condition produced = lock.newCondition();
     Condition consumed = lock.newCondition();
     boolean available = false;   

     public void produce() throws InterruptedException {
           lock.lock();
           try {
                 if(available){
                    consumed.await(); //放弃lock进入睡眠  
                 }
                 /*生产苹果*/
                 System.out.println("Apple produced.");
                 available = true;
                 produced.signal(); //发信号唤醒等待这个Condition的线程
           } finally {
                lock.unlock();
           }
     }

     public void consume() throws InterruptedException {
           lock.lock();
           try {
                 if(!available){
                  produced.await();//放弃lock进入睡眠  
                 }
                 /*吃苹果*/
                 System.out.println("Apple consumed.");
                 available = false;
                 consumed.signal();//发信号唤醒等待这个Condition的线程
           } finally {
                 lock.unlock();
           }
     }      
}

public class ConditionTester {

      public static void main(String[] args) throws InterruptedException{
        final Basket basket = new Basket();
          //定义一个producer
            Runnable producer = new Runnable() {
                  public void run() {
                        try {
                              basket.produce();
                        } catch (InterruptedException ex) {
                             ex.printStackTrace();
                        }
                  }
};

           //定义一个consumer
            Runnable consumer = new Runnable() {
                  public void run() {
                        try {
                              basket.consume();
                        } catch (InterruptedException ex) {
                              ex.printStackTrace();
                        }
                  }
};

          //各产生10个consumer和producer
            ExecutorService service = Executors.newCachedThreadPool();
            for(int i=0; i < 10; i++) {
                  service.submit(consumer);
            }
            Thread.sleep(2000);
            for(int i=0; i<10; i++) {
                  service.submit(producer);
            }
            service.shutdown();
      }      
}