java基础－－Java 5.0多线程编程（1）

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();

                }

        }

}