多线程之jdk 5.0新增的两种创建方式

第一种方式：实现callable接口

创建线程的方式三：实现callable接口 -------jdk5.0新增
返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。
Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
接口 Executor
执行已提交的 Runnable 任务的对象。此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。通常使用 Executor 而不是显式地创建线程。例如，可能会使用以下方法，而不是为一组任务中的每个任务调用 new Thread(new(RunnableTask())).start()：

Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());

Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。

例：输出100以内的偶数 及其和

//1.创建一个实现callable接口的实现类
class NumThread implements Callable {
    //2.实现call方法  将此线程需要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i=1;i<=100;i++){
            if (i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此callable实现类的对象作为参数传递到 FutureTask构造器中 创建 FutureTask对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask类的对象作为参数传递到Thread类的构造器中 创建Thread类对象并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取callable中call方法的返回值
            //get()方法的返回值即为FutureTask构造器参数callable实现类重写的call方法的返回值
            Object sum = futureTask.get();
            System.out.println("总和为"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

何理解实现callable接口的方式创建多线程比实现Runnable接口创建多线程强大？
 *    1、call（）方法可以有返回值
 *    2.call（）方法可以抛出异常，被外面的操作捕获 抛出异常信息
 *    3.callable是支持泛型的

第二种方式：使用线程池

背景：频繁的创建线程 对性能影响非常大
方法：提前创建好多个线程放进线程池中，使用时获取使用完放回线程池中
优点：
1.提高响应
2.降低资源消耗
3.便于管理

创建线程的方式四：使用线程池
 *  corePoolSize：核心池的大小
 *  maximumPoolSize：最大线程数
 *  keepAliveTime：线程没有任务时最多保持多长时间后会终止

例 ：多线程执行 一个输出奇数一个输出偶数

class Number implements Runnable{

    @Override
    public void run() {
        for (int i=0;i<=100;++i){
            if (i%2==0){
                //输出100以内的偶数
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class Number1 implements Runnable{
//输出奇数
    @Override
    public void run() {
        for (int i=0;i<=100;++i){
            if (i%2!=0){
                //输出100以内的奇数
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
     //newFixedThreadPool:创建一个可重用固定线程数的线程池
        //1.提供指定数量的线程池  创建10条可重用的线程 返回值是ExecutorService 是一个接口
        ExecutorService service = Executors.newFixedThreadPool(10);
        //把ExecutorService强转为实现类ThreadPoolExecutor才能设置属性
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //设置线程池的属性
        service1.setCorePoolSize(15);//核心池的大小
//        service1.setKeepAliveTime();//设置活跃时间
        service1.setMaximumPoolSize(15);//最大线程数

        //2.执行指定的线程操作。需要实现Runnable接口或callable接口实现类的对象
          //execute适合于使用Runnable
        //传进一个runnable 会帮我们执行run方法
         service.execute(new Number());
         service.execute(new Number1());
//         service.submit();//适合适用于callable
        //3.关闭线程池
        service.shutdown();//归还线程
    }
}