多线程程序实现的方式3

多线程程序实现的方式3

• 提交的是Callable

    // 创建线程池对象
    ExecutorService pool = Executors.newFixedThreadPool(2);
  
    // 可以执行Runnable对象或者Callable对象代表的线程
    Future<Integer> f1 = pool.submit(new MyCallable(100));
    Future<Integer> f2 = pool.submit(new MyCallable(200));
  
    // V get()
    Integer i1 = f1.get();
    Integer i2 = f2.get();
  
    System.out.println(i1);
    System.out.println(i2);
  
    // 结束
    pool.shutdown();
  
    public class MyCallable implements Callable<Integer> {
  
    	private int number;
    
    	public MyCallable(int number) {
    		this.number = number;
    	}
    
    	@Override
    	public Integer call() throws Exception {
    		int sum = 0;
    		for (int x = 1; x <= number; x++) {
    			sum += x;
    		}
    		return sum;
    	}
    
    }
  

• 多线程程序实现的方式3的好处和弊端

  • 好处：
    • 可以有返回值
    • 可以抛出异常
  • 弊端：
    • 代码比较复杂，所以一般不用

package com.heima.thread2;

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

public class Demo06_Callable {

	/**
	 * @param args
	 * @throws ExecutionException 
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);
		//可以执行Runnable对象或者Callable对象代表的线程
		Future<Integer> f1 = pool.submit(new MyCallable(100));
		Future<Integer> f2 = pool.submit(new MyCallable(50));
		//V get()
		System.out.println(f1.get());
		System.out.println(f2.get());
		//结束
		pool.shutdown();
	}
}

class MyCallable implements Callable<Integer> {
	private int num;

	public MyCallable(int num) {
		this.num = num;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= num; i++) {
			sum += i;
		}
		return sum;
	}
}