Java多线程的建立(二)

• 前言：

  虽然java的API中说建立多线程的方式只有两种（There are two ways to create a new thread of execution），分别是继承Thread类建立和实现Runnable接口建立，在上一篇博文中演示了这两种，详见，可是JDK5.0之后新增了两种，分别是实现Callable接口建立和使用线程池建立，本次就演示后两种建立方式并分析其特性。

  ---

• 实现Runnable接口建立多线程

  建立步骤：

  1.建立一个实现Callable接口的类。

  2.重写call()方法，线程须要执行的代码都放到call方法中。

  3.建立实现Callable接口类的实例对象。

  4.将步骤 3 的对象做为参数传给FutureTask构造器中，建立FutureTask对象。

  5.将FutureTask的对象做为参数传给Thread类，建立对象并调用start()方法。

package day02;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//建立一个多线程，输出20之内的偶数，并返回全部偶数的和
//1.建立一个实现`Callable`接口的类。  
class TestSum implements Callable{
   //2.重写call()方法，线程须要执行的代码都放到call方法中。
    @Override
    public Object call() throws Exception{
        int sum = 0;
        for(int i = 1;i <= 20 ;i++ ){
            if(i % 2 == 0){
                System.out.println(i);
                sum = sum + i;
            }
        }
        return sum;
    }
}

public class ThreadCall {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.建立实现`Callable`接口类的实例对象。
        TestSum test = new TestSum();
        //4.将步骤 3 的对象做为参数传给`FutureTask`构造器中，建立`FutureTask`对象。
        FutureTask futuretask = new FutureTask(test);
        //5.将`FutureTask`的对象做为参数传给`Thread`类，建立对象并调用start()方法。
        Thread thread = new Thread(futuretask);
        thread.start();
        //get方法能够获取返回值
        System.out.println("偶数总合是："+futuretask.get());
    }
}
//输出结果：
2
4
6
8
10
12
14
16
18
20
偶数总合是：110

实现Callable接口建立多线程的特色：

​ 1.call()方法能够有返回值，能够使用get()方法获取返回值。

​ 2.call()方法能够抛出异常， 并且能被外面捕获到。

​ 3.Callable支持泛型。

---

• 使用线程池建立多线程

  一.实现Runnable接口的方式建立:

package day02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Number implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args){
        ExecutorService service = Executors.newFixedThreadPool(10);
        Number num = new Number();
        service.execute(num);
        service.shutdown();

---

二.实现Callable接口的方式建立:

package day02;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Number implements Callable {
    @Override
    public Object call() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
        return null;
    }
}

public class ThreadPool {
    public static void main(String[] args){
        ExecutorService service = Executors.newFixedThreadPool(10);
        Number num = new Number();
        service.submit(num);//区别在这里
        service.shutdown();
    }
}

• 线程池好处：

  1.频繁建立线程和销毁使用量较大的资源，好比并发的线程，对性能影响较大，因此须要建立线 程池存放线程，使用的时候直接获取，实现重复利用，提升效率。

  2.下降建立线程时间，提升响应速度。

  3.下降资源的消耗。

  4.便于线程管理。