Java 多线程 线程池

线程池 主要用来解决线程生命周期开销问题和资源不足问题

线程池 容纳多个线程的容器，线程池中的线程可以被反复使用，从而避免频繁创建线程对象的操作，减少系统资源的消耗

 

/*
* JDK1.5新特性,实现线程池程序
* 使用工厂类 Executors中的静态方法创建线程对象,指定线程的个数
* static ExecutorService newFixedThreadPool(int 个数) 返回线程池对象
* 该对象 实质是 ExecutorService接口的实现类对象，此对象可调用方法submit()   用以提交线程执行任务
*/

 

 使用线程池中线程对象的步骤

1.创建线程池对象   ExecutorService threadPool = Executors.newFixedThreadPool(2)  //工厂类 Executors的 静态方法

2.创建 Runnable 或 Callable 接口的实现类对象  MyRunnable r = new MyRunnable()

3.线程池对象以submit()方法 提交 Runnable 或 Callable 接口的子类对象  ，则池中线程 自动调用 子类对象中的 run()方法  或 call()方法  

 　　　　　　  submit(Runnable task)  // run()方法 无返回值   不能抛异常   

<T> Future<T> submit(Callable<T> task)  // Future接口：用来记录线程任务执行完毕后产生的结果   call()方法 有返回值 可以抛异常

4.关闭线程池  service.shutdown() 

注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

Callable接口   来自 java.util.concurrent包     该接口与Runnable接口功能相似， 该接口支持泛型！ 该接口的call()方法用来执行线程任务，且在执行完毕后可返回结果，call方法可抛出异常

 

public class ThreadPoolRunnable implements Runnable {
    public void run(){
        System.out.println(Thread.currentThread().getName()+" 线程提交任务");
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //调用工厂类的静态方法,创建线程池对象
        //返回线程池对象,是返回的接口
        ExecutorService es = Executors.newFixedThreadPool(2);
        //调用接口实现类对象es中的方法submit提交线程任务
        //将Runnable接口实现类对象,传递
        es.submit(new ThreadPoolRunnable());
        es.submit(new ThreadPoolRunnable());

    
    }
}

 

import java.util.concurrent.Callable;

public class ThreadPoolCallable implements Callable<String>{
    public String call(){
        return "abc";
    }
}

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


public class ThreadPoolDemo1 {
    public static void main(String[] args)throws Exception {
        ExecutorService es = Executors.newFixedThreadPool(2);
        //提交线程任务的方法submit方法返回 Future接口的实现类
        Future<String> f = es.submit(new ThreadPoolCallable());
        String s = f.get();
        System.out.println(s);
    }
}

 

 

 

多线程的两个求和计算的异步

import java.util.concurrent.Callable;

public class GetSumCallable implements Callable<Integer>{
    private int a;
    public GetSumCallable(int a){
        this.a=a;
    }
    
    public Integer call(){
        int sum = 0 ;
        for(int i = 1 ; i <=a ; i++){
            sum = sum + i ;
        }
        return sum;
    }
}

 

/*
 * 使用多线程技术,求和
 * 两个线程,一个线程计算1~100的求和,另一个线程计算1~200的求和
 * 多线程的异步计算
 */
public class ThreadPoolDemo {
    public static void main(String[] args)throws Exception {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Integer> f1 =es.submit(new GetSumCallable(100));
        Future<Integer> f2 =es.submit(new GetSumCallable(200));
        System.out.println(f1.get());
        System.out.println(f2.get());
        es.shutdown();
    }
}