线程池bing

最新推荐文章于 2024-05-11 14:58:37 发布
最新推荐文章于 2024-05-11 14:58:37 发布
阅读量218 收藏
点赞数
分类专栏： 多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiqipengcheng/article/details/118079287
版权

上一篇

目录标题

前言

线程缺点:
1.线程的创建它会开辟本地方法栈、虚拟机栈、程序计数器成线程私有的内存，同时消耗的时候需要销毁以上3个区域，因此频繁的创建和消耗比较消耗系统资源;
2.在任务量远远大于线程可以处理的任务量的时候，并不能友好拒绝任务。
线程池定义:使用池化技术来管理线程和使用线程的方式。
线程池的优点
1.可以避免频繁的创建和消耗线程。
2.可以更好的管理线程的个数和资源的个数。
3.拥有更多的功能，比如线程池可以进行定时任务的执行。
4.线程池可以更优化的拒绝不能处理的任务。

线程池的创建

线程池的创建总共分为7种。

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

 public static void main(String[] args) {

        // 创建一个固定个数的线程池
        ExecutorService executorService =
                Executors.newFixedThreadPool(10);
        for (int i = 0; i < 2; i++) {
            // 执行任务
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" +
                            Thread.currentThread().getName());
                }
            });
        }
    }

该线程池是懒加载模式，只有放接受的线程数大于初始化的线程数，它才建立线程（它最大能建立10个线程，超过了10复用之前建立的线程）。

2.创建缓存的线程池

使用场景:短期有大量任务的时候时候使用newCachedThreadPool()

  public static void main(String[] args) {
        // 创建带缓存的线程池
        ExecutorService executorService =
                Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" +
                            Thread.currentThread().getName());
                }
            });
        }
    }

3.自定义线程池规则（线程池的名称、优先级…)

   public static void main(String[] args) {
        // 自定义线程工厂
        MyThreadFactory threadFactory = new MyThreadFactory();
        ExecutorService executorService =
                Executors.newFixedThreadPool(10, threadFactory);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    Thread thread = Thread.currentThread();
                    System.out.println("线程名：" +
                            thread.getName() +
                            ",优先级：" + thread.getPriority());
                }
            });
        }
    }

    private static int count = 1;

    static class MyThreadFactory implements ThreadFactory {

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            // 自定义线程池的名称规则
            thread.setName("mythreadpool-" + count++);
            // 设置优先级
            thread.setPriority(10);
            return thread;
        }
    }

4.创建定时任务的线程池

 public static void main(String[] args) {
        // 创建执行定时任务的线程池
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(1);
        System.out.println("设置定时任务：" + new Date());
//        // 1.执行定时任务
//        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.println("执行任务：" + new Date());
//            }
//        }, 1, 3, TimeUnit.SECONDS);
          // 2.执行定时任务
//        scheduledExecutorService.schedule(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("执行任务：" + new Date());
//            }
//        }, 1, TimeUnit.SECONDS);
            // 3.执行定时任务
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行任务：" + new Date());
            }
        }, 1, 3, TimeUnit.SECONDS);

    }

第一种：
参数1:线程执行的任务Runnable参数2:延迟一段时间执行
参数3:定时任务执行的频率
参数4:配合参数2和参数3使用的，它规定了时间的单位
第二种：
推迟某秒，只会执行一次
第三种
scheduleWithFixedDelay

scheduleAtFixedRate:以上次任务的开始时间作为下一次任务的开始时间的。
scheduleWithFixedDelay:以上次任务的结束时间作为下一次任务的开始时间的。

5.创建单线程执行定时任务的线程池

 public static void main(String[] args) {
        // 创建单个执行定时任务的线程池
        ScheduledExecutorService service =
                Executors.newSingleThreadScheduledExecutor();
        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("执行任务：" + new Date());
            }
        }, 1, 3, TimeUnit.SECONDS);

    }

6.创建单线程的线程池

   public static void main(String[] args) {
        // 创建单个线程的线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" +
                            Thread.currentThread().getName() +
                            ",I=" + finalI);
                }
            });
        }

    }

补充：创建单个线程池的好处

1.可以避免频发创建和消耗线程带来的性能开销;
2.有任务队列可以存储多余的任务;
3.当有大量的任务不能处理的时候，可以友好的执行拒绝策略;
4.线程池可以更好的管理任务（保证任务的先进先出）。

7.创建异步运行的线程池（jdk8+支持）

更具当前的CPU的个数生成对应线程（异步）个数的线程池。
在这里插入图片描述

   public static void main(String[] args) {
        // 创建一个异步根据当前CPU生产的线程池
        ExecutorService service = Executors.newWorkStealingPool();
        for (int i = 0; i < 100; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" +
                            Thread.currentThread().getName());
                }
            });
        }

        // 等待线程池执行完成
        while (!service.isTerminated()) {
        }

    }

总结

线程池有两个重要的对象:
1.线程
2.工作队列(前面创建线程池的工作队列中任务量 Integer最大值)
如果使用前6种创建线程池的方式会导致的问题:
1.线程数量不可控（比如创建带缓存的线程池时）;
2.工作任务量不可控（ Integer.MAX_VALUE)，可能会导致内存溢出。

8.原始创建线程池的方法

  private static int count = 1;

    public static void main(String[] args) {

        // 创建线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("myThreadPool-" + count++);
                return thread;
            }
        };

        // 原始的创建线程池的方式
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(1, 1,
                        60, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(8),
                        threadFactory,
                        new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 10; i++) {
            final int finalI = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(finalI + " 线程名：" +
                            Thread.currentThread().getName());
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

在这里插入图片描述
在创建线程池时最大线程数不能超过核心线程数
在这里插入图片描述

  private static int count = 1;

    public static void main(String[] args) {

        // 创建线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("myThreadPool-" + count++);
                return thread;
            }
        };

        // 原始的创建线程池的方式
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(1, 1,
                        60, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(8),
                        threadFactory,
                        new RejectedExecutionHandler() {
                            @Override
                            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                // 自定义拒绝策略，可以写到日志里面，也可以存储到数据库，也可以啥都不做
                                System.out.println("执行了拒绝策略");
                            }
                        });
        for (int i = 0; i < 10; i++) {
            final int finalI = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(finalI + " 线程名：" +
                            Thread.currentThread().getName());
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

ThreadPoolExecutor执行流程

在这里插入图片描述

线程池的状态

在这里插入图片描述
线程池总共存在5种状态:
RUNNING:线程池创建之后的初始状态，这种状态下可以执行任务。
SHUTDOWN:该状态下线程池不再接受新任务，但是会将工作队列中的任务执行结束。
STOP:该状态下线程池不再接受新任务，但是不会处理工作队列中的任务，并且将会中断线程。。
TIDYING:该状态下所有任务都已终止，将会执行terminated()钩子方法。
TERMINATED:执行完terminated ()钩子方法之后。

线程执行的两种方式

1.执行任务无返回值excute(new Runnable… . )
2.执行任务有返回值sumbit(Runnbale 无返回值/Callable有返回值)

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(10, 10, 60, TimeUnit.SECONDS,
                        new LinkedBlockingQueue<>(100));
        // 执行任务方式1
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行 execute 方法");
            }
        });
        // 执行一个带返回值的任务
        Future<Integer> future = threadPoolExecutor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // 生成随机数
                int num = new Random().nextInt(10);
                System.out.println("执行submit方法，随机数：" + num);
                return num;
            }
        });
        System.out.println("得到线程池执行结果：" + future.get());
        // 使用 submit 执行 Runnable 任务
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行submit方法，使用的是Runnable对象");
            }
        });
        threadPoolExecutor.shutdown();
    }

参考文章

下一篇

月屯
关注
专栏目录
爬虫小案例：基于Bing关键词批量下载图片（第二版）
采菊东篱下，Python满乾坤！
03-29 974
一、需求： 基于Bing网站，输入关键词，批量下载图片保存到本地 二、代码展示： import requests from lxml import etree import os from multiprocessing.dummy import Pool import json from time import time # 作用：按关键字、图片数量爬取必应图片，存放到指定路径。 # 使用方法：只需运行一条命令 BingImagesSpider('美女壁纸', 200, 'E:\images'
反射 动态代理 线程池
C_CXY2333的博客
09-10 406
反射 动态代理 线程池 反射 动态获取类的字节码文件，并对其进行抽象 通过反射可以获取一个类的全部方法和属性，然后进行调用。 反射与类之间抽象的理解：Class 将字节码对象进行抽象 出现了： 1.属性：表示字节码文件的属性的属性：private Field field; 2.属性：表示字节码文件的普通方法的属性：private Mathod method; 3.属性:表示字节码文件的构造方法...
多线程下的单例模式（线程安全）——懒加载
sayhitoloverOvO的博客
10-25 720
package springboot.rabbit.controller; public class Singleton { //使用volatilt关键字修饰，可以阻止CPU指令重排，并保证其可见性 private volatile static Singleton singleton = null; //私有化构造方法，确保不会在其他地方产生新的对象 private Singleton() { System.out.println("new Singleton-------");.
线程池懒加载实现初探
cqstart116的专栏
04-24 1067
单例类： package com.ldy.utils; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.LinkedBlockingQueue; i
线程池原理简谈
最新发布
qq_40900926的博客
05-11 826
线程池是一种池化技术，本质是减少线程对象创建销毁的开销，同对象池、连接池一样，达到对象复用的效果。那么线程池怎么复用呢？即一个或多个Thread对象怎么执行更多的Task？这里面的关键就涉及到了阻塞队列。其一，所谓阻塞队列，是借助锁实现的生产-消费模型，以BlockLinkedList为例，其taskFirst方法，通过notEmpy，即Condition实现阻塞等待功能，而Condition内部使用了AQS来实现锁的功能，详情可见。
java线程池
有个疙叫瘩儿的博客
06-07 701
线程池创建及重要参数： 线程池可以自动创建也可以手动创建，自动创建体现在Executors工具类中，常见的可以创建newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor、newScheduledThreadPool。 可以通过Executors类来创建线程池，但是不推荐。Executors类只是静态工厂，提供创建线程池的几个静态方法，而真正的线程池类是ThreadPoolExecuor。构造方法如下： 转存失败重新上传取消 c
多线程之四：线程池
2301_81298401的博客
11-29 130
Java线程池实现原理及其在美团业务中的实践 - 美团技术团队★★★★★线程池的使用场景-CSDN博客线程池整理汇总-CSDN博客线程池详解-CSDN博客Java线程池（超详细）-CSDN博客百度安全验证1. 什么是线程池开发中，为了执行效率，一些任务需要多线程去完成，而线程本身的创建并销毁往往需要大量的开销，因而引入线程池的概念。一种池化思想。2. 使用场景略。从名字上就可以看出，当前线程池是用于执行定时任务的线程池。Java比较早的定时任务工具是Timer类。
Java爬取 百度图片&Google图片&Bing图片
08-14
在本项目中，我们主要探讨的是如何使用Java编程语言来实现对百度、Google以及Bing这三个主流搜索引擎的图片抓取功能。这个项目名为"ImageCrawler"，它可能是一个简单的命令行工具，用于批量下载指定关键词的网络图片...
并发与多线程(四) --- 线程池
weixin_47081743的博客
11-02 608
文章目录一、线程池的好处1.1 线程池的作用：1.2 线程是如何创建的二、使用步骤1.引入库2.读入数据总结 一、线程池的好处 线程使应用能够更加充分合理地协调利用CPU、内存、网络、I/O等系统资源。线程的创建需要开辟虚拟机栈、本机方法栈、程序计数器等线程私有的内存空间。在线程销毁时需要回收这些资源。 频繁地创建和销毁线程会浪费大量的系统资源，增加并发编程风险。另外，在服务器负载过大的时候，如何让新的线程等待或者友好地拒绝服务？这些都是线程自身无法解决的。 所以需要通过线程池协调多个线程，并实现类似主次
httpclient4.3 线程池超时问题解决
zzyymaggie的专栏
04-11 3055
之前采用Httpclient4.3写了一个抓取服务，突然有一天线上出现了很多这样的报警Read time out 和 ConnectionPoolTimeoutException: Timeout waiting for connection使用连接池的原因是：没有连接池的话，多少次请求就会建立多少个IO，在访问量巨大的情况下服务器的IO可能会耗尽。1 检查连接是否关闭EntityUtils.con
深入理解 Java 线程池技术
weixin_46017166的博客
11-21 527
看完这篇文章彻底搞透线程池技术
给大家来一波线程池的问题连环炮
04-26 468
1、为什么会有线程池 JVM中的一个线程即对应一个操作系统的线程，也就是JVM的线程是由操作系统创建而来，创建线程和销毁线程这些都需要操作系统来分别赋予资源和释放资源等 也就意味着创建线程变成了一个比较重的操作 我们可以利用多线程去进行不同的工作，更高效的利用CPU资源，但是这并不意味着线程数量越多越好 我们的时代已经由原来的单核时代变成现在的多核时代了，这个核指的就是CPU，在原来的单核时代，如果一个线程一直是运算的逻辑过程，也就不涉及到线程的切换，因为这个线程一直在占用CPU，也就是属于计算密集型 但.
线程池（二）：ThreadPoolExecutor
骑着蜗牛向前跑的博客
05-26 608
线程池的状态 ThreadPoolExectuor 使用 int 的高 3 位来表示线程池的状态，低 29 为表示线程数量。 状态名 高 3 位 接收新任务 处理阻塞队列任务 说明 RUNNING 111 Y Y SHUTDOWN 000 Y Y 不会接收新任务，但会处理阻塞队列剩余任务 STOP 001 N N 会中断正在执行的任务，并抛弃阻塞队列任务 TIDYING 010 - - 任务全部执行完毕，活动线程为0即将进入终结 TERMINATED 011 - - 终结状
Java多线程编程环境中单例模式的实现
blacksky115的专栏
09-06 777
Abstract         在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制，也就是说只有当使用到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了广泛应用。这个机制在single-threaded环境下的实现非常简单，然而在multi-threaded环境下却存在隐患。本文重点介绍惰性加载机制以及其在多线程环境下的使用方法。（作者numberze
多线程下单例模式：懒加载（延迟加载）和即时加载
tianqiqing2012的博客
06-05 921
转自《https://www.cnblogs.com/jingpeipei/p/5771716.html》在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制，也就是说只有当使用到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了广泛应用。这个机制在single-threaded环境下的实现非常简单，然而在multi-threaded环境下却存在隐患。本文重点介...
多线程java懒加载问题
xiao5122122455的专栏
12-03 1231
在多线程编程下，java懒加载初始化出现了一个这样的问题，初始化java类时会出现多个实例。
用懒加载方式实现一个单列模式（注意：需要考虑多线程并发情况）
萤火虫草花星的博客
06-18 688
1、懒汉式-线程不安全 这个实现在多线程环境下是不安全的，如果多个线程能够同时进入if (uniqueInstance == null)，并且此时uniqueInstance == null，那么会有多个线程执行uniqueInstance = new Singleton();语句，这将导致实例化多次uniqueInstance。 // 懒汉式: 线程不安全 // 有延迟加载...
单例模式：懒加载（延迟加载）和即时加载
oldmonk
07-16 364
在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制，也就是说只有当使用到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了广泛应用。这个机制在single-threaded环境下的实现非常简单，然而在multi-threaded环境下却存在隐患。本文重点介绍惰性加载机制以及其在多线程环境下的使用方法。(作者numberzero，参考IBM文章《Dou...
Java线程池看懂这一篇就够了！
墨柔千城的博客
06-05 335
线程池1.概念2.为什么要使用线程池？2.1线程的缺点2.2使用线程池的原因3.线程池的创建方法3.1创建固定个数的线程3.2创建带缓存的线程池3.3创建能执行定时任务的线程池3.4创建单个执行定时任务的线程池3.5创建单个线程的线程池3.6根据当前工作环境（CPU核心数、任务量）异步线程4.Executors创建线程池的问题5.开发中使用的线程池技术6.线程池特征 1.概念 概念：使用池化技术来管理和使用线程的技术，就叫做线程池。 线程池里面包含的重要内容： 线程 任务队列 2.为什么要使用线程池？
Bing Maps开发完全指南：从入门到精通
"Bing Maps教程 - 从入门到精通 - 杨文泉 - 2010-12-09" 这篇教程是关于Bing Maps接口的应用指南，适合开发者学习如何使用Bing Maps API进行开发。教程分为学习篇、进阶篇和应用与技巧篇，以及附录，涵盖了从基础到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月屯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值