Java线程（线程池、创建线程的第三种方法callable)

线程池

补充资料：Doug Lea (JCP组织的一人)对线程池部分贡献巨大

 

常用线程池的接口和类：

Executor:线程池的顶级接口

ExecutorService:线程池接口可用submit（Runnable Task）提交任务代码。包含：Shutdown；

Shutdownnow等

Executors工厂类:可以通过这一个方法得到一个线程池

NewFixedThreadPool(int n Thread):获取固定数量的线程池。参数：指线程池中线程的数量

NewCacheThreadPool()获取动态数量的线程池，无上限

 

对于ExecutorService:需关注实现类TheadPoolExecutor，SheduledThreadPoolExecutor

Executors:1.创建固定线程个数的线程池

2.创建缓存线程池，又任务多少来决定

3.创建单线程池

4.创建调度线程池  调度：周期、定时执行

 

在API中：

Shutdown：启动一次顺序关闭，执行以前提交的任务，但不接受新任务

ShutDownNow：试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表

 

代码示例1 固定线程个数：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

public class Demo {

    public static void main(String[] args) {

//        1.创建固定线程个数的线程池

        ExecutorService es=Executors.newFixedThreadPool(4);

//        2.提交任务

        Runnable run=new Runnable() {

            private int ticket;

 

            @Override

            public void run() {

                while (true) {

                    if (ticket <= 0) {

                        break;

                    }

                    System.out.println(Thread.currentThread().getName() + "卖完第：" + ticket + "张票");

                    ticket--;

                }

            }

        };

//        3.提交任务

                for(int i=0;i<=4;i++) {

            es.submit(run);

        }

//        4.关闭线程池

        es.shutdown();

        }

}

 

 

 

代码示例 2 可变线程个数，由任务决定

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Demo {
    public static void main(String[] args) {
//        1.创建固定线程个数的线程池
//        ExecutorService es=Executors.newFixedThreadPool(4);
        ExecutorService es2=Executors.newCachedThreadPool();
//        2.提交任务
        Runnable run=new Runnable() {
            private int ticket;
 
            @Override
            public void run() {
                while (true) {
                    if (ticket <= 0) {
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() + "卖完第：" + ticket + "张票");
                    ticket--;
                }
            }
        };
//        3.提交任务
                for(int i=0;i<=4;i++) {
            es2.submit(run);
        }
//        4.关闭线程池
        es2.shutdown();
        }
}

 

注：提交任务数不一定是4.要具体看运行结果

 

Excutors的另外两种方法

3. ExecutorService e3=Executors.newSingleThreadExecutor();

4. ExecutorService e4=Executors.newScheduledThreadPool();

 

 

Callable接口

语法：

Public interface Callable<V>{public V call() throws Exception}

特点：有返回值；使用时需要先转化为任务后被Thread调用

 

代码示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
 
public class Demo02 {
    public static void main(String[] args) {
//        功能需求：计算1-100的和并使用Callable接口
        Callable<Integer> callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"开始计算");
                int sum = 0;
                for (int j = 1;j<=100;j++){
                    sum+=j;
                    Thread.sleep(100);
                }
                return sum;
 
            }
        };
//        把Callable转化为可执行的任务
        FutureTask<Integer> task = new FutureTask<>(callable);
 
//        创建线程
        Thread thread = new Thread(task);
 
//        启动线程
        thread.start();
 
//        获取结果
        Integer sum= null;
        try {
            sum = task.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("结果是"+sum);
        }
}

 

 

 

Callable与线程池的结合的使用

这种方法与线程池的配合更为紧密

优点：无需先转化为task，再进行执行；

需求示例：使用Callable和线程池计算1-100的和

代码示例：

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

 

public class Demo03 {

    public static void main(String[] args) throws Exception {

//        1. 创建线程池

        ExecutorService es = Executors.newFixedThreadPool(1);

//        2.提交任务Future:表示将要执行任务的结果

        Future<Integer> future =  es.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                System.out.println(Thread.currentThread().getName()+"开始计算");

                int sum=0;

                for (int i=0;i<=100;i++){

                    sum+=i;

                }

                return sum;

            }

        });

//        3.获取任务结果

       System.out.println(future.get());

 

//        4.关闭线程池

        es.shutdown();

    }

}

 

 

 

 

Future接口

功能：表示将要完成的任务的结果

案例需求：使用两个线程，并发计算1-50和51-100的和，再进行汇总统计

Future.get()方法需要等待callable的方法执行完毕才可以继续执行，即 同步

关于同步、异步：我们现在手头有两个线程A\B，A在使用过程中会调用B线程。同步的含义是例如A需要执行三个部分，在第一个部分时调用了B，调用之后不继续执行第二个部分而是等待B被调用完之后再继续执行第二第三个部分。

异步的含义是，A执行第一部分并调用了B线程，A不继续等待B线程执行完而接着执行第二部分第三部分。

代码示例：

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

 

public class Demo4 {

    public static void main(String[] args) throws Exception{

//        1.创建线程池

        ExecutorService es = Executors.newFixedThreadPool(2);

//        2.创建任务及对象

        Future<Integer> future =es.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                int sum=0;

                for(int i=0;i<=50;i++){

                    sum+=i;

                }

                return sum;

            }

        });

 

        Future<Integer> future2=es.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                int sum=0;

                for(int i=51;i<=100;i++){

                    sum+=i;

                }

                return sum;

            }

        });

//      3.获取结果

        int sum=future.get()+future2.get();

        System.out.println("结果是" + sum);

 

//        4.关闭线程

        es.shutdown();

    }

}