Java 学习记录-14

import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
	//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 CallableTest {  
    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();  
        }  
    }  
}

import java.util.concurrent.*;  
  
class NumberThread implements Runnable{  
    @Override  
    public void run() {  
        for(int i = 0;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 = 0;i <= 100;i++){  
            if(i % 2 != 0){  
                System.out.println(Thread.currentThread().getName() +  
                        ": " + i);  
            }  
        }  
    }  
}  
class NumberThread2 implements Callable {  
    @Override  
    public Object call() throws Exception {  
        int evenSum = 0;//记录偶数的和  
        for(int i = 0;i <= 100;i++){  
            if(i % 2 == 0){  
                evenSum += i;  
            }  
        }  
        return evenSum;  
    }  
}  
public class Test {  
    public static void main(String[] args) {  
        //1. 提供指定线程数量的线程池  
        ExecutorService service = Executors.newFixedThreadPool(10);//设置线程池维持至少10个线程数（不论有几个在使用）
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//使用其子类，功能更多，通过强制转换更便捷，直接使用参数过多
        service1.setMaximumPoolSize(50); //设置线程池中线程数的上限  
        
	    System.out.println(service.getClass());//ThreadPoolExecutor
        //2.执行指定的线程的操作。
        //需要提供实现 Runnable 接口或 Callable 接口实现类的对象  
        service.execute(new NumberThread());//适合适用于 Runnable        
        service.execute(new NumberThread1());//适合适用于 Runnable        
        try {  
            Future future = service.submit(new NumberThread2());//适合使用于 Callable            
            System.out.println("总和为：" + future.get());  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        //3.关闭连接池  
        service.shutdown();  
    }  
}