Java 线程池总结 线程中断

理论:

1 Executors 预置 4种线程池: Fixed  SingleThread  cached  Scheduled 
2 FutureTask 使用方法: 新建callable<T>对象;将Callable对象submit 线程池中,会返回Future对象,然后 可以通过get 获取对应数据,但是会等待
3 ExecutorCompletionService 接收线程队列,内置一个BlockingQueue,有数据才返回

 

 


线程池: 
  ThreadPoolExecutor : 
   CorepoolSize  核心池大小
   MaxPoolSize 最大池大小 ,只有工作对列满了,才会扩大最大池
   KeepAliveTime 空闲线程保留时间
   TimeUnit  保留单位
   WorkQueue  工作对列,
   ThreadFactory 线程工厂,主要定制线程名称
   RejectedExecutionHandler :饱和策略,默认为AbortPolicy, 饱和就废弃,但是会抛出 RejectedExecutionException(非检查异常)

 

线程池使用说明corepoolsize maxpoolsize后台使用队列
newCachedThreadPool无限容量线程池运行队列;0Integer.MAX_VALUESynchronousQueue:无容量、无缓冲队列
newFixedThreadPool固定线程池队列
 Executors.newFixedThreadPool(1);
定义时指定与corepoolsize 相同LinkedBlockingQueue 无限队列
newSingleThreadExecutor顺序运行队列,FIFO,一次只执行一个线程11LinkedBlockingQueue 无限队列
newScheduledThreadPool线程定时任务执行器;可以放置无限多线程执行,并且可以使用固定周期 与固定时延方式运行线程,一般用于执行定时任务,不会放置无限多线程。定义时指定Integer.MAX_VALUEDelayedWorkQueue 无限容量堆数组

 

TestCachedThreadExecutors

/**
 * newCachedThreadPool  corepool size 0, maxpool  无限大,
 * 后台使用了 SynchronousQueue 无容量无缓冲等待队列,线程直接交给maxpool去执行
 * 可以并行运行无限大线程池,并且线程池可以复用(前一个线程用完即可)
 */
public class TestCachedThreadExecutors {

    private CountDownLatch cdLatch = new CountDownLatch(3);

    public static void main(String[] args) {

        Executor cachedExecutors =  Executors.newCachedThreadPool();
        ThreadTask t1 = new ThreadTask();
        ThreadTask t2 = new ThreadTask();
        ThreadTask t3 = new ThreadTask();

        cachedExecutors.execute(t1);
        cachedExecutors.execute(t2);
        cachedExecutors.execute(t3);
        showVM();

        for(int i=0;i<1000;i++){
            ThreadTask t  = new ThreadTask();
            cachedExecutors.execute(t);
            if(i%100==0){showVM();
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
        }


    }


    public static class ThreadTask  implements  Runnable{

        private Byte[] datas = new Byte[10240];

        @Override
        public void run() {
            try {

                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void showVM(){
        List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
            System.out.println("Name:" + memoryPoolMXBean.getName());
            System.out.println("Usage:" + memoryPoolMXBean.getUsage());
            System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
            System.out.println("Type:" + memoryPoolMXBean.getType());
            System.out.println("--------------------------");
        }
    }
}
TestFixedThreadExecutors
/**
 * newFixedThreadPool corePoolSize = maxPoolSize,
 * 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
 */
public class TestFixedThreadExecutors {

    private CountDownLatch cdLatch = new CountDownLatch(3);

    public static void main(String[] args) {

        Executor fixedExecutors =  Executors.newFixedThreadPool(1);
        ThreadTask t1 = new ThreadTask();
        ThreadTask t2 = new ThreadTask();
        ThreadTask t3 = new ThreadTask();

        fixedExecutors.execute(t1);
        fixedExecutors.execute(t2);
        fixedExecutors.execute(t3);

        showVM();

        for(int i=0;i<1000;i++){
            ThreadTask t  = new ThreadTask();
            fixedExecutors.execute(t);
            if(i%100==0){showVM();
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
        }


    }


    public static class ThreadTask  implements  Runnable{

        private Byte[] datas = new Byte[1024000];

        @Override
        public void run() {
            try {

                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void showVM(){
        List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
            System.out.println("Name:" + memoryPoolMXBean.getName());
            System.out.println("Usage:" + memoryPoolMXBean.getUsage());
            System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
            System.out.println("Type:" + memoryPoolMXBean.getType());
            System.out.println("--------------------------");
        }
    }
}
TestSingleThreadExecutors
/**
 * newSingleThreadExecutor  一次执行一个线程,并且保证线程顺序执行,
 * 后台使用了 LinkedBlockingQueue 无限队列,可以放置无限多线程
 */
public class TestSingleThreadExecutors {

    private CountDownLatch cdLatch = new CountDownLatch(3);

    public static void main(String[] args) {

        Executor singleExecutors =  Executors.newSingleThreadExecutor();
        ThreadTask t1 = new ThreadTask();
        ThreadTask t2 = new ThreadTask();
        ThreadTask t3 = new ThreadTask();

        singleExecutors.execute(t1);
        singleExecutors.execute(t2);
        singleExecutors.execute(t3);
        showVM();

        for(int i=0;i<1000;i++){
            ThreadTask t  = new ThreadTask();
            singleExecutors.execute(t);
            if(i%100==0){showVM();
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
        }


    }


    public static class ThreadTask  implements  Runnable{

        private Byte[] datas = new Byte[1024];

        @Override
        public void run() {
            try {

                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void showVM(){
        List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
            System.out.println("Name:" + memoryPoolMXBean.getName());
            System.out.println("Usage:" + memoryPoolMXBean.getUsage());
            System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
            System.out.println("Type:" + memoryPoolMXBean.getType());
            System.out.println("--------------------------");
        }
    }
}
TestScheduledThreadExecutors
/**
 * newScheduledThreadPool  corepool 用户设置, maxpool  无限大,
 * 后台使用了 DelayedWorkQueue 无限制容量堆数组,线程直接交给maxpool去执行
 * 可以放置无限多线程执行,并且可以使用固定周期 与固定 时延方式运行线程
 * 一般不会放置无限多线程。
 */
public class TestScheduledThreadExecutors {

    private CountDownLatch cdLatch = new CountDownLatch(3);

    public static void main(String[] args) {

        ScheduledExecutorService scheduledExecutorService =  Executors.newScheduledThreadPool(3);
        ThreadTask t1 = new ThreadTask();
        ThreadTask t2 = new ThreadTask();
        ThreadTask t3 = new ThreadTask();

        scheduledExecutorService.schedule(t1,3, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(t2,2000,2000,TimeUnit.SECONDS);
        scheduledExecutorService.scheduleWithFixedDelay(t3,2000,2000,TimeUnit.SECONDS);

        showVM();

        for(int i=0;i<1000;i++){
            ThreadTask t  = new ThreadTask();
            scheduledExecutorService.execute(t);
            if(i%100==0){showVM();
            System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + i);}
        }


    }


    public static class ThreadTask  implements  Runnable{

        private Byte[] datas = new Byte[10240];

        @Override
        public void run() {
            try {

                Thread.sleep(5000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void showVM(){
        List<MemoryPoolMXBean> mxb = ManagementFactory.getMemoryPoolMXBeans();
        for (MemoryPoolMXBean memoryPoolMXBean : mxb) {
            System.out.println("Name:" + memoryPoolMXBean.getName());
            System.out.println("Usage:" + memoryPoolMXBean.getUsage());
            System.out.println("Manager:" +","+  memoryPoolMXBean.getMemoryManagerNames());
            System.out.println("Type:" + memoryPoolMXBean.getType());
            System.out.println("--------------------------");
        }
    }
}
TestCompletionService
/**
 * 实现原理:ExecutorCompletionService 类,内部定义了一个 BlockingQueue<Future<T>>;
 * 当线程执行完成,有返回时,往 BlockingQueue 中add Futurn<T>;
 * 具体怎么判断线程执行完成呢:重载类FutureTask.done()方法,完成相关功能
 *
 * 使用场景:当使用线程池运行需要有返回值的线程时,为了获取结果不被阻塞,需要使用此方法
 */
public class TestCompletionService {



    public static void main(String[] args) throws InterruptedException, ExecutionException {
         Executor executorService = Executors.newFixedThreadPool(3);
        List<Callable<String>> callableList = new ArrayList<>();

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

            final String name = "name" + i;
            final int sleepTime = new Random().nextInt(10);

            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {

                    System.out.println("Thread name :" + name + ",sleeptime :" + sleepTime);
                    TimeUnit.SECONDS.sleep(sleepTime);
                    return "found " + name;
                }
            };
            callableList.add(callable);
        }

        CompletionService<String> completionService = new ExecutorCompletionService<String>(executorService);

        for (int i = 0; i < callableList.size(); i++)
            completionService.submit(callableList.get(i));

        for (int i = 0; i < callableList.size(); i++) {
            System.out.println("等待打印" + (i + 1) + "个返回值");
            System.out.println(completionService.take().get());
        }

    }

}
TestExecutorInvokeAll
public class TestExecutorInvokeAll {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        List<Callable<String>> callableList = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            final String name = "Thread " + i;
            final int sleepTime = new Random().nextInt(10);
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("begin " + name);
                    TimeUnit.SECONDS.sleep(sleepTime);
                    return name;
                }
            };

            callableList.add(callable);
        }

        List<Future<String>> futureList = executorService.invokeAll(callableList, 5, TimeUnit.SECONDS);

        for (int i = 0; i < futureList.size(); i++) {
            if (!futureList.get(i).isCancelled()) {
                System.out.println(futureList.get(i).get());
            } else {
                System.out.println(callableList);
            }
        }

    }
}
TestThreadInterrupt
/**
 * interrupt结论:
 * 1 interrupt() 可以中断线程;
 * 2 Thread.sleep() wait() /join()方法 检测到线程中断后,会抛出 InterruptedException 异常,然后清除中断状态(),线程回到正常状态
 * 3 Thread.interrupted() 判断当前线程状态,若未中断状态则返回true,并清除中断状态,线程回到正常状态; 若未中断,返回false,不去中断线程;
 * 4 Thread.currentThread().isInterrupted() 仅判断当前线程状态,若中断返回true,否则返回false;
*interrupt 使用步骤:
*1 制定中断策略
*2 在合适地方中断线程,interrupt()
*3 在业务流程决策点判断 线程中断状态
*4 捕获线程中断异常,处理中断逻辑
 */

public class TestThreadInterrupt {
    public static void main(String[] args) throws InterruptedException {

        MyRunnable myRunnable = new MyRunnable("Thread test");
        Thread t1 = new Thread(myRunnable);
        t1.start();
        Thread.sleep(10000l);
        t1.interrupt();


    }


    static class MyRunnable implements Runnable {

        private String name;

        public MyRunnable(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            int i = 0;
            System.out.println("begin thread  " + name);

            while (i < 10 && !Thread.currentThread().isInterrupted()) {
                try {
                    TimeUnit.SECONDS.sleep(2);
                    i++;
                    System.out.println("finish  loop  " + i);

                } catch (InterruptedException e) {
                    System.out.println("Thread  " + name + " loop " + i + " encounter InterruptedException , and interrupt status: " + Thread.currentThread().isInterrupted());

                    System.out.println("after interruptedException check, thread isInterrupted() = " + Thread.currentThread().isInterrupted());

                    boolean interruptedFlag =  Thread.interrupted();

                    System.out.println("after interrupted() once , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);

                    interruptedFlag =  Thread.interrupted();

                    System.out.println("after interrupted() twice , thread isInterrupted() = " + Thread.currentThread().isInterrupted() + ", interruptedFlag = " + interruptedFlag);

                      Thread.currentThread().interrupt();

                    System.out.println("after interrupt() , thread isInterrupted() = " + Thread.currentThread().isInterrupted() );

                    interruptedFlag =  Thread.interrupted();

                    System.out.println(" interrupted() after  interrupted(), interruptedFlag = " + interruptedFlag + ",thread isInterrupted() = " + Thread.currentThread().isInterrupted() );


                }

            }

            System.out.println("end  thread  " + name);

        }
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值