Java 5.0多线程编程

核心提示： java自1995年面世以来得到了广泛得一个运用，但是对多线程编程的支持Java很长时间一直停留在初级阶段，Java 5.0多线程编程，在Java 5.0之前Java里的多线程编程主要是通过Thread类，Runnable接口，一不小心就会出现死锁现象， 假如线程因拿不到锁定而进入等待状况，Object对象中的wa

　  java自1995年面世以来得到了广泛得一个运用，但是对多线程编程的支持Java很长时间一直停留在初级阶段。在Java 5.0之前Java里的多线程编程主要是通过Thread类，Runnable接口，Object对象中的wait()、 notify()、 notifyAll()等方法和synchronized要害词来实现的。这些工具虽然能在大多数情况下解决对共享资源的治理和线程间的调度，但存在以下几个问题

1.　　  过于原始，拿来就能用的功能有限，即使是要实现简单的多线程功能也需要编写大量的代码。这些工具就像汇编语言一样难以学习和使用，比这更糟糕的是稍有不慎它们还可能被错误地使用，而且这样的错误很难被发现。

2.　　  假如使用不当，会使程序的运行效率大大降低。

3.　　  为了提高开发效率，简化编程，开发人员在做项目的时候往往需要写一些共享的工具来实现一些普遍适用的功能。但因为没有规范，相同的工具会被重复地开发，造成资源浪费。

4.　　  因为锁定的功能是通过Synchronized来实现的，这是一种块结构，只能对代码中的一段代码进行锁定，而且锁定是单一的。如以下代码所示：

synchronized（lock）{

　  //执行对共享资源的操作

　  ……

}

　   一些复杂的功能就很难被实现。比如说假如程序需要取得lock A和lock B来进行操作1，然后需要取得lock C并且释放lock A来进行操作2，Java 5.0之前的多线程框架就显得无能为力了。

　 因为这些问题，程序员对旧的框架一直颇有微词。这种情况一直到Java 5.0才有较大的改观，一系列的多线程工具包被纳入了标准库文件。这些工具包括了一个新的多线程程序的执行框架，使编程人员可方便地协调和调度线程的运行，并且新加入了一些高性能的常用的工具，使程序更轻易编写，运行效率更高。本文将分类并结合例子来介绍这些新加的多线程工具。

　 在我们开始介绍Java 5.0里的新Concurrent工具前让我们先来看一下一个用旧的多线程工具编写的程序，这个程序里有一个Server线程，它需要启动两个Component，Server线程需等到Component线程完毕后再继续。相同的功能在Synchronizer一章里用新加的工具CountDownLatch有相同的实现。两个程序，孰优孰劣，哪个程序更轻易编写，哪个程序更轻易理解，相信大家看过之后不难得出结论。

public class ServerThread {

　　  Object concLock = new Object();

　　  int count = 2;

public void runTwoThreads() {

　　  //启动两个线程去初始化组件

　　　　　  new Thread(new ComponentThread1(this)).start();

　　　　　  new Thread(new ComponentThread1(this)).start();

　　　　　  // Wait for other thread

while(count != 0) {

　　　　　　　　  synchronized(concLock) {

　　　　　　　　　　　  try {

　　　　　　　　　　　　　　  concLock.wait();

　　　　　　　　　　　　　　  System.out.PRintln("Wake up.");

　　　　　　　　　　　  } catch (InterruptedException ie) { //处理异常}

　　　　　　　　  }

　　　　　  }

　　　　　  System.out.println("Server is up.");

　　  }

　　  public void callBack() {

synchronized(concLock) {

　　　　　　　　  count--;

　　　　　　　　  concLock.notifyAll();

　　　　　  }

　　  }

　　  public static void main(String[] args){

　　　　　  ServerThread server = new ServerThread();

　　　　　  server.runTwoThreads();

　　  }

}

 

public class ComponentThread1 implements Runnable {

　　  private ServerThread server;

　　  public ComponentThread1(ServerThread server) {

　　　　　  this.server = server;

　　  }

public void run() {

　　  //做组件初始化的工作

　　　　　  System.out.println("Do component initialization.");

　　　　　  server.callBack();

　　  }

}

1：三个新加的多线程包

　 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包包含锁定的工具。

2：Callable 和 Future接口

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

• Callable规定的方法是call()，而Runnable规定的方法是run().
• Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
• call（）方法可抛出异常，而run（）方法是不能抛出异常的。
• 运行Callable任务可拿到一个Future对象，通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

以下是Callable的一个例子：

public class DoCallStuff implements Callable{ // *1

　　　  private int aInt;

　　　  public DoCallStuff(int aInt) {

　　　　　　　  this.aInt = aInt;

　　　  }

　　　  public String call() throws Exception { //*2

　　　　　　　  boolean resultOk = false;

　　　　　　　  if(aInt == 0){

　　　　　　　　　　　  resultOk = true;

　　　　　　　  }  else if(aInt == 1){

　　　　　　　　　　　  while(true){ //infinite loop

　　　　　　　　　 　　　　　　 System.out.println("looping....");

　　　　　　　　　　　　　　　  Thread.sleep(3000);

　　　　　　　　　　　  }

　　　　　　　  } else {

　　　　　　　　　　　  throw new Exception("Callable terminated with Exception!"); //*3

　　　　　　　  }

　　　　　　　  if(resultOk){

　　　　　　　　　　　  return "Task done.";

　　　　　　　  } else {

　　　　　　　　　　　  return "Task failed";

　　　　　　　  }

　　　  }

}

*1: 名为DoCallStuff类实现了Callable，String将是call方法的返回值类型。例子中用了String，但可以是任何Java类。

*2: call方法的返回值类型为String，这是和类的定义相对应的。并且可以抛出异常。

*3: call方法可以抛出异常，如加重的斜体字所示。

以下是调用DoCallStuff的主程序。

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class Executor {

　　　  public static void main(String[] args){

　　　　　　　  //*1

　　　　　　　  DoCallStuff call1 = new DoCallStuff(0);

　　　　　　　  DoCallStuff call2 = new DoCallStuff(1);

　　　　　　　  DoCallStuff call3 = new DoCallStuff(2);

　　　　　　　  //*2

　　　　　　　  ExecutorService es = Executors.newFixedThreadPool(3);

　　　　　　　  //*3

　　　　　　　  Future future1 = es.submit(call1);

　　　　　　　  Future future2 = es.submit(call2);

　　 　　　　　 Future future3 = es.submit(call3);

　　　　　　　  try {

　　　　　　　　　　　  //*4

　　　　　　　　　　　  System.out.println(future1.get());

　　　　　　　　　　　　 //*5

　　　　　　　　　　　  Thread.sleep(3000);

　　　　　　　　  　　　System.out.println("Thread 2 terminated? :" + future2.cancel(true));

　　　　　　　　　　　  //*6

　　　　　　　　　　　  System.out.println(future3.get());

　　　　　　　  } catch (ExecutionException ex) {

　　　　　　　　　　　  ex.printStackTrace();

　　　　　　　  } catch (InterruptedException ex) {

　　　　　　　　　　　  ex.printStackTrace();

　　　　　　　  }

　　　  }

}

 

 

*1: 定义了几个任务

*2: 初始了任务执行工具。任务的执行框架将会在后面解释。

*3: 执行任务，任务启动时返回了一个Future对象，假如想得到任务执行的结果或者是异常可对这个Future对象进行操作。Future所含的值必须跟Callable所含的值对映，比如说例子中Future对印Callable

*4: 任务1正常执行完毕，future1.get()会返回线程的值

*5: 任务2在进行一个死循环，调用future2.cancel(true)来中止此线程。传入的参数标明是否可打断线程，true表明可以打断。

*6: 任务3抛出异常，调用future3.get()时会引起异常的抛出。

 运行Executor会有以下运行结果：

looping....

Task done. //*1

looping....

looping....//*2

looping....

looping....

looping....

looping....

Thread 2 terminated? :true //*3

//*4

java.util.concurrent.ExecutionException: java.lang.Exception: Callable terminated with Exception!

　　　  at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:205)

　　　  at java.util.concurrent.FutureTask.get(FutureTask.java:80)

　　　  at concurrent.Executor.main(Executor.java:43)

　　　  …….

*1: 任务1正常结束

*2: 任务2是个死循环，这是它的打印结果

*3: 指示任务2被取消

*4: 在执行future3.get()时得到任务3抛出的异常

3：新的任务执行架构

　 在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提于交和执行是同时进行的，假如你想对任务的执行进行调度或是控制同时执行的线程数量就需要额外编写代码来完成。5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，并且可以建立一个类似数据库连接池的线程池来执行任务。这个架构主要有三个接口和其相应的具体类组成。这三个接口是Executor, ExecutorService和ScheduledExecutorService，让我们先用一个图来显示它们的关系：

 

  图的左侧是接口，图的右侧是这些接口的具体类。注重Executor是没有直接具体实现的。

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所指定的时间后重复执行。

代码：ScheduleExecutorService的例子

public class ScheduledExecutorServiceTest {

　　　  public static void main(String[] args)

　　　　　　　 throws InterruptedException, ExecutionException{

　　　　　　　 //*1

　　　　　　　  ScheduledExecutorService service = Executors.newScheduledThreadPool(2);

　　　　　　　  //*2

　　　　　　　  Runnable task1 = new Runnable() {

　　　　　　　　　　 public void run() {

　　　　　　　　　　　  System.out.println("Task repeating.");

　　　　　　　　　　 }

　　　　　　　  };

　　　　　　　  //*3

　　　　　　　  final ScheduledFuture future1 =

　　　　　　　　　　　  service.scheduleAtFixedRate(task1, 0, 1, TimeUnit.SECONDS);

　　　　　　　  //*4

　　　　　　　  ScheduledFuture future2 = service.schedule(new Callable(){

　　　　　　　　　　 public String call(){

　　　　　　　　　　　　　　 future1.cancel(true);

　　　　　　　　　　　　　　 return "task cancelled!";

　　　　　　　  　　 }

　　　　　　　  }, 5, TimeUnit.SECONDS);

　　　　　　　  System.out.println(future2.get());

//*5

service.shutdown();

　　　  }

}

　 这个例子有两个任务，第一个任务每隔一秒打印一句“Task repeating”,第二个任务在5秒钟后取消第一个任务。

*1: 初始化一个ScheduledExecutorService对象，这个对象的线程池大小为2。

*2: 用内函数的方式定义了一个Runnable任务。

*3: 调用所定义的ScheduledExecutorService对象来执行任务，任务每秒执行一次。能重复执行的任务一定是Runnable类型。注重我们可以用TimeUnit来制定时间单位，这也是Java 5.0里新的特征，5.0以前的记时单位是微秒，现在可精确到奈秒。

*4: 调用ScheduledExecutorService对象来执行第二个任务，第二个任务所作的就是在5秒钟后取消第一个任务。

*5: 关闭服务。

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里等待执行

以下是得到和使用ExecutorService的例子：

代码：如何调用Executors来获得各种服务对象

//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要害字来实现的，这样做存在几个问题：

• 每次只能对一个对象进行锁定。若需要锁定多个对象，编程就比较麻烦，一不小心就会出现死锁现象。
• 假如线程因拿不到锁定而进入等待状况，是没有办法将其打断的

在Java 5.0里出现两种锁的工具可供使用，下图是这两个工具的接口及其实现：