线程池

1.为什么使用线程池

•  线程缺乏统一管理,占用过多系统资源

• 缺乏更多功能,如定时执行、定期执行等

2.使用线程池的好处

• 重用存在的线程,减少对象创建、消亡的开销

• 有效控制最大并发数,提高系统资源使用率

• 定时执行、定期执行

3.JAVA,线程池API

• 线程池所在包java.util.concurrent

• 顶级接口是Executor ,真正的线程池接口是ExecutorService

• java.util.concurrent. Executors类提供创建线程池的方法

可以下载        帮助文档，去了解更多

 

 3.1使用newCachedThreadPool ( )方法创建线程池

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

/**
 * 使用newCachedThreadPool ( )方法创建线程池
 * 缓存线程池
 */
public class Test {
    public static void main(String[] args) {
        ExecutorService cache= Executors.newCachedThreadPool();//创建一个线程池
        //在线程池面执行10任务
       for (int i=0;i<10;i++){
           cache.execute(new MyRunnable(i));
           // try {
            //    Thread.sleep(500);//模拟网络延迟
            //} catch (InterruptedException e) {
                //e.printStackTrace();
           // }
       }
    }
}
class MyRunnable implements Runnable{
      int num;//代表任务数
     public MyRunnable(int num){
        this.num=num;
     }
    @Override
    public void run() {
    System.out.println(Thread.currentThread().getName()+":"+num);
    }
}

3.2.使用newSingle ThreadExecutor()创建一个单线程池

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

/**
 * 使用newSingle ThreadExecutor()创建一个单线程池
 */
public class Single {
    public static void main(String[] args) {
        ExecutorService cache= Executors.newSingleThreadExecutor();//创建一个线程池
        for (int i=0;i<10;i++){
            cache.execute(new MyRunnable(i))    ;
        }
    }
}

3.3.使用newFixedThreadPool( )方法创建线程池

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

/**
 * 使用newFixedThreadPool( )方法创建线程池
 */
public class Fixed {
    public static void main(String[] args) {
        ExecutorService cache= Executors.newFixedThreadPool(3);//创建一个线程池,可以设置创建线程池的个数
        for (int i=0;i<10;i++){
            cache.execute(new MyRunnable(i)) ;
        }
    }
}

3.4.使用newScheduledThreadPool ( )方法来创建线程池

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 使用newScheduledThreadPool ( )方法来创建线程池
 */
public class Sched {
    public static void main(String[] args) {
   ScheduledExecutorService sched=Executors.newScheduledThreadPool(3);//设置创建线程池的个数
        System.out.println("**************开始执行**************");
        sched.scheduleAtFixedRate(new MYrunnable()  ,1,2,TimeUnit.SECONDS);
    }
}
class MYrunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"延时时间1秒，每2秒执行一次");
    }
}

4.ThreadPool Executor类

      4.1.构造器中各个参数的含义

• corePoolSize :核心池的大小

• maximumPoolSize :线程池最大线程数

• keepAliveTime :表示线程没有任务执行时最多保持多久时间会终止

• unit :参数keepAliveTime的时间单位

• workQueue : -个阻塞队列,用来存储等待执行的任务

• threadFactory :线程工厂,主要用来创建线程

• handler :表示当拒绝处理任务时的策略

 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 创建自定义线程池
 */
public class Diamond {
    public static void main(String[] args) {
        //创建一个自定义的线程池
        ThreadPoolExecutor executor=new ThreadPoolExecutor(5,7,300, TimeUnit.MICROSECONDS,new ArrayBlockingQueue<Runnable>(4));
                 for(int i=0;i<12;i++){
                          executor.execute(new ryunnable(i));
                          System.out.println("线程池中的线程数"+executor.getPoolSize()+",队列中等待执行的任务数:"+executor.getQueue().size()+",你执行完的任务数:"+executor.getCompletedTaskCount());
                      }
                      executor.shutdown();
    }
}
class ryunnable implements Runnable{
        int num;//第几个任务
    public ryunnable(int num){
        this.num=num;
    }

    @Override
    public void run() {
    System.out.println("正在执行任务"+num);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务"+num+"执行完毕");
    }
}