[Java知识库]Java_线程池

Java_线程池的概念

1. Java线程池表示一组正在等待作业并重复使用多次的工作线程
2. 在线程池的情况下,创建一组固定大小的线程,来自线程池中的线程被拉去并由服务提供者分配作业,完成作业后,线程将会被再次包含在线程池中

线程池的优点:线程池提供了更好的新能,因为不需要重新创建新线程,所以节省了时间
在Servlet和JSP中使用线程池,容器创建一个线程来处理请求

package com.company;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 线程池实例


class WorkerThread implements Runnable {
    private String message;

    public WorkerThread(String s) {
        this.message = s;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始信息 = " + message);
        processmessage();// call processmessage method that sleeps the thread for 2 seconds
        System.out.println(Thread.currentThread().getName() + " 结束");// prints thread name
    }

    private void processmessage() {
        try {
            Thread.sleep(2000); // 休眠 2 秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}



public class Java_30 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);//calling execute method of ExecutorService
        }
        executor.shutdown();
        while (!executor.isTerminated()) {   }

        System.out.println("所有线程执行完毕");
    }


}

Java_常用线程池接口和类(所在包java.util.concurrent):

1. Executor:线程池顶级接口
2. ExecutorService：线程池接口，可通过submit（Runnable task）提交任务。
3. Executors工具类：通过此类可以获得一个线程池。
4. 通过newFixedThreadPool（int nThreads）：获取固定数量的线程池。参数：指定线程池中线程的数量。
5. newCashedThreadPool（）：获得动态数量的线程池，如不够则重新创建新的，没有上限。

package com.company;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 线程池实例二 :详细使用线程池
public class Java_31 {
    public static void main(String[] args){
        //创建固定个数的线程池
        // ExecutorService es=Executors.newFixedThreadPool(5);
        //创建动态线程池
        ExecutorService es= Executors.newCachedThreadPool();
        //创建单线程线程池
        //Executors.newSingleThreadExecutor();
        //创建调度线程池
        //Executors.newScheduledThreadPool();
        // 创建任务
        Runnable runnable=new Runnable() {
            private int ticket=100;
            @Override
            public void run() {
                while (true){
                    if (ticket<=0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                    ticket--;
                }
            }
        };
        //提交任务
        for (int i =0;i<5;i++){//5=上面的线程池个数
            es.submit(runnable);
        }
        //关闭线程池
        es.shutdown();
    }
}

Java_Callable接口和Future创建线程

1. 创建 Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
2. 创建Callable实现类的实例，使用 FutureTask 类来包装Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call()方法的返回值。
3. 使用 FutureTask 对象作为 Thread 对象的 target创建并启动新线程。
4. 调用FutureTask对象的 get() 方法来获得子线程执行结束后的返回值。

Callable接口:

1. Callable接口 与Runnable接口类似，实现之后代表一个接口任务。
2. Callable具有泛型返回值,可以声明异常

package com.company;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// Callable 接口样例

/**
 * 演示Callable接口的使用
 * Callable与Runnable接口的区别：
 * ?    1、Callable中call方法具有泛型返回值、Runnable接口中run方法没有返回值
 *     2、Callable中call方法可以声明异常，Runnable接口中run方法没有异常
 */
public class Java_33 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //功能需求，使用Callable实现1-10的和
        //1、创建Callable对象
        Callable<Integer> callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算");
                int sum=0;
                for (int i=0;i<=10;i++){
                    sum+=i;
                }
                return sum;
            }
        };
        //把Callable对象转成任务
        FutureTask<Integer> task=new FutureTask<>(callable);
        //创建线程
        Thread thread=new Thread(task);
        thread.start();
        //获取结果
        Integer sum = task.get();
        System.out.println("计算结果是："+sum);
    }
}

Future接口:表示将要完成任务的结果
线程池+Callable接口+Future+接口的综合使用

package com.company;

import java.util.concurrent.*;

// 线程池+Callable+Future+接口的综合使用
/**
 * 要求：计算1-100的和
 *    使用两个线程，并发计算1-50、51-100的和，再进行汇总统计。
 */
public class Java_34 {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //创建线程池
            ExecutorService es = Executors.newFixedThreadPool(2);
            //提交任务
            Future<Integer> future=es.submit(new Callable<Integer>() {
                private int sum=0;
                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName()+"开始计算");
                    for (int i=0;i<=50;i++){
                        sum+=i;
                    }
                    return sum;
                }
            });
            Future<Integer> future2=es.submit(new Callable<Integer>() {
                private int sum=0;
                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName()+"开始计算");
                    for (int i=51;i<=100;i++){
                        sum+=i;
                    }
                    return sum;
                }
            });
            //汇总
            int sum=future.get()+future2.get();
            System.out.println("计算结果是："+sum);
        }
    }