JDK5.0之后新增的线程创建方式

package com.atguigu.java2;

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

/**
 * 创建线程的方式三：实现Callable接口， ---JDK5.0新增
 * 1.创建一个实现Callable接口的实现类
 * 2.实现call方法，将此线程需要执行的操作声明在call()方法中
 * 3.创建Callable接口实现类的对象
 * 4.将Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
 * 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
 * 6.获取Callable中call方法的返回值
 * <p>
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1.call()可以有返回值的
 * 2.call(可以抛出异常，被外面的操作捕获，获取异常信息
 * 3.Callable是支持泛型的
 *
 * @author shkstart
 * @create 2021-08-27 13:40
 */

class NumberThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }

        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        NumberThread numberThread = new NumberThread();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numberThread);
        new Thread(futureTask).start();
        try {
            //get()返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
            Integer sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

package com.atguigu.java2;

import java.lang.reflect.Executable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四：使用线程池
 * 好处：
 *  提高响应速度（减少了创建新线程的时间）
 *  降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 *  便于线程管理
 * corePoolSize：核心池的大小
 * maximumPoolSize：最大线程数  keepAliveTime：线程没有任务时最多保持多长时间后会终止
 *
 * 面试题：创建多线程有几种方式？四种，继承Thread，实现Runnable接口，实现Callable接口
 * 线程池
 * ExecutorService service = Executors.newFixedThreadPool(10);
 *
 * @author shkstart
 * @create 2021-08-27 14:32
 */

class NumberThread7 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 NumberThread8 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <= 100; 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);//多态
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//强转
        service1.setCorePoolSize(15);
        //service1.setKeepAliveTime();
        //设置线程池的属性
        //System.out.println(service.getClass());
        //执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread7());//适合使用于Runnable
        service.execute(new NumberThread8());//适合使用于Runnable
        //service.submit();//适合使用于Callable
        service.shutdown();
    }
}