Java，多线程，线程的创建方式三、四：实现Callable与线程池

创建多线程的方式三：实现Callable（jdk5.0新增）
步骤：
①创建一个实现 Callable 的实现类。
②实现 call 方法，将此线程需要执行的操作声明在 call() 中。
③创建 Callable 接口实现类的对象。
④将此 Callable 接口的实现类的对象作为传递到 FutureTask 的构造器中，创建 FutureTask 的对象。
⑤将 FutureTask 的对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象，并调用 start()。
⑥获取 Callable 中 call 方法的返回值。
实现Callable接口的代码以下为例：

java 复制代码

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


//①创建一个实现Callable的实现类
class NumThread implements Callable
{
//②实现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;
            }
            Thread.sleep(200);
        }
        return sum;
    }
}


public class CallableTest {
    public static void main(String[] args)
    {
        //③创建Callable接口实现类的对象
        NumThread nn = new NumThread();


        //④将此Callable接口的实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象。
        FutureTask ff = new FutureTask(nn);


        //⑤将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread类的对象，并调用start()
        Thread t1 = new Thread(ff);
        t1.start();


        try
        {
            //⑥获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call的返回值
            Object sum = ff.get();
            System.out.println("总和为：" + sum);
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

与之前的方式的对比：与Runnable的方式对比的好处

·call( )方法有返回值，更灵活。

·call( )方法可以使用throws的方式处理异常。

·Callable使用了泛型参数，可以指明具体的call( )的返回值类型。

实现Callable的创建方式的缺点：

如果在主线程中需要获取分线程call( )的返回值，则此时的主线程是阻塞状态的。

创建多线程的方式四：使用线程池

线程池使得线程可以复用，即执行完一个任务，并不被销毁，而是可以继续执行其他的任务。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中。可以避免频繁创建销毁、实现重复利用。

此方式的好处：

·提高了程序执行的效率。（因为线程已经提前被创建好了）

·提高了资源的复用率。（因为执行完的线程并未销毁，而是可以继续执行其他的任务）

·可以设置相关的参数，对线程中的线程进行管理。

具体的代码及步骤如下：

java 复制代码

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


public class ThreadPool
{
    public static void main(String[] args)
    {
        //①提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor ss = (ThreadPoolExecutor) service;
        //设置线程池的属性
        ss.setMaximumPoolSize(50);//设置线程池中线程数的上限


        //②执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        ss.execute(new NumberThread());//适用于Runnable接口的实现类的对象
        ss.execute(new NumberThread1());


        //ss.submit(Callable callable);//适用于callable接口的实现类的对象


        //③关闭连接池
        ss.shutdown();
    }


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


class NumberThread1 implements Runnable
{
    @Override
    public void run()
    {
        for (int i = 1;i <= 100;i++)
        {
            if(i % 2 == 1)
            {
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}