「java线程池面试题」线程线程池面试题

admin 2023-03-20 00:43:10 239

今天给各位分享java线程池面试题的知识，其中也会对线程线程池面试题进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、作为一个面试官，我会问初级java工程师哪些问题？
2、求java工程师面试题？
3、线程池的一些面试题
4、我要面试了，给些java面试基础问题，在线等
5、java的面试题有哪些？
6、面试题：线程池有几种实现方式，线程池的七大参数有哪些？

作为一个面试官，我会问初级java工程师哪些问题？

初级java工程师多数是刚毕业或者工作1,2年的新人。对于新人，面试中基础问题会问道很多，因为先要考察这个人的基础。

关于基础类的题目，我在面试初级java工程师的时候一般会问下面两大类问题，每类5个题目，这样下来我就基本可以了解这位工程师的程度了。

java基础类

面向对象基础类

java基础类

1.描述一下java的访问修饰符，和它们之间的区别？

回答：如果可以回到出public，private，protected，就算是ok；回答出default的，加分。

2. int和Integer 区别？

回答：如果回答出Integer是int的包装类，就算ok；回答出其他的基本类型和它们相应的包装类，加分。

3.如何定义一个单精度浮点类型的变量？

回答：float 变量名=1.2f ；回答出不加最后的f为双精度浮点类型，加分

4. equals和==的区别？

回答： equals是值比较（一般处理java开发都会这么说，算是ok的）而==是引用比较（或者对象比较）；回答equals是可以自定义的，加分

5.将一个数组作为参数传递到一个方法中，在方法中，数组内的元素值被改变了，那么在方法外部，这个数组内的元素是否也被改编了？

回答：是，因为java方法中传递的是引用，就ok。如果回答中，将引用说明了自己的理解，加分。

面向对象基础类

1.重载和重写的区别？

回答：这个看个人理解，理解没有什么大的偏差就ok；回答出多态相关的，加分。

2.构造方法能不能重载？

回答：可以重载，ok；回答构造方法时不能继承的，所以如果要调用指定父类构造器就必须重写子类构造方法，加分。

3.抽象方法（abstract）是否可以被final、static、native修饰？

回答：都不可以，因为抽象方法是必须子类实现的，final方法时不可以被重写的，static是父类必须实现的方法，native是本地语言实现的方法。回答出封装和继承相关的，加分

4.当父类引用指向子类对象的时候，子类重写了父类方法和属性，那么当访问属性的时候，访问是谁的属性？调用方法时，调用的是谁的方法？

回答：访问的是父类的属性，调用的是子类的方法，ok；如果可以画图解释的话，加分

5.抽象类和接口有什么异同？

回答：一些类定义上的区别，ok；回答在应用过程中，如何根据业务定义接口，加很多分

最后，如果前面问题回答的不错，会补充两个编程习惯问题。

1.在你写过的代码中，你写过超过2层的循环吗，怎么实现的？

回答：没有，就算ok；如果回答有，听一下实现，如果原因说不出来，扣分。

2.在你写过的代码中，if语句最多嵌套了几层，最多有多少分支，怎么实现的？

回答：3层以下，就算ok；如果回答3层以上，听一下实现，如果原因说不出来，扣分。

4，5个分支，就算ok；如果回答5个分支以上，听一下实现，如果原因说不出来，扣分。

最后两个题其实比较陷阱，但是正是一个反向的思考才能了解面试者之前的工作状态。

如果面试者在平日里就有好的习惯，自然不用担心。

求java工程师面试题？

1.介绍一下你自己吧 ——简单说说你的大学、专业、特长、志向

2.你了解我们公司的工作吗？有兴趣吗？——对你要做的工作给出理解同时用事实说明自己有兴趣

3.你经常到java论坛吗？最喜欢哪一个？——最好说CSDN和ITEYE，别人一听就知道你很有研究。

4.你会考研吗？你怎么看待加班和跳槽？——看你是不是能在公司待下去，一定要说自己不考研，专心在公司好好干，踏实干，如果你说“人总是往高处走的”别人就怀疑你干一年就跳槽！

5.剩下是我总结的经常出现的面试题，答案你可以在这里继续提问。

1. 写出你最常用的5个类和5个接口。

2. 写出你所知道的排序算法。并用Java实现一个快速排序。

3. 实现4个线程，其中2个每次加1，另外2个每次减1。

4. 写出你最常遇到的5个异常，并简单描述它们发生在什么情况下。

5. 用单例模式实现一个线程池。

6. 如何存储一个整数，这个整数的长度大于2的64次方。

7. 写一段代码，当用户输入a,在屏幕上显示b，在D:\test.txt中写入c。

8. Swing组件用的进程条是什么类？

9. JSP里面哪个内置对象可以提交客户的请求？

10. 什么是同步？实现线程同步的关键字是什么？如果已经出现死锁，你如何解决？

线程池的一些面试题

1,为什么要用线程池,优势

(1)降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

(2) 提高响应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。

(3) 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.1常用方式

那java中是怎样实现的线程池呢？是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个接口或类，它们都是JUC包下的。 java.util.concurrent.Executors类是Executor的辅助类，类似于java中操作数组的辅助类java.util.Arrays，以及操作集合的java.util.Collections类

1.2:Executors类中的主要三个方法

线程安全的队列:staticQueue queue = new ConcurrentLinkedQueueString();

(1) 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中的等待，它创建的线程池corePoolSize和maximnumPoolSize是相等的，它使用的是LinkedBlockingQueue;

源码如下:

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueueRunnable());

}

(2)Executors#newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行，它将corePoolSize和maximnumPoolSize都设置为1，它也使用的是LinkedBlockingQueue;

源码:

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueueRunnable()));

}

(3)Executors#newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。，它将corePoolSize设置为0，将maximnumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当前线程空闲超过60秒，就销毁线程;

源码:

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueueRunnable());

}

2,线程池的重要参数:

源码:

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

参数:

corePoolSize

线程池中的常驻核心线程数，在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。

maximumPoolSize

线程池能够容纳同时执行的最大线程数，此值必须大于等于1。

keepAliveTime

多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。

unit

keepAliveTime的单位。

workQueue

任务队列，被提交但尚未被执行的任务。

threadFactory

表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。

handler

拒绝策略，表示当队列满了，再也塞不下新任务了，同时，工作线程大于等于线程池的最大线程数，无法继续为新任务服务，这时候我们就需要拒绝策略机制合理的处理这个问题，默认会抛异常，那拒绝策略有哪些呢，我们继续往下看。

JDK内置的接口:RejectedExcutionHandle

AbortPolicy（默认）

直接抛出java.util.concurrent.RejectedExecutionException异常阻止系统正常运行，这种方式显然是不友好的。

CallerRunsPolicy

"调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

DiscardOldestPolicy

抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

DiscardPolicy

直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种解决方案。

具体选择哪一种的拒绝策略，也是看自己的系统需求了;

3,底层工作原理

(1).在创建了线程池后，等待提交过来的任务请求

(2).当调用execute()方法添加一个请求任务时，线程池会做如下判断

2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务

2.2 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列

2.3 如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务

2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行

(3). 当一个线程完成任务时，它会从队列中取下一个任务来执行

(4). 当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断

4.1 如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉

4.2 所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小

创建线程池时，配置多少线程数是合理的:

(1)CPU密集型:CPU核数+1个线程的线程池(CPU密集任务只有在真正的多核CPU上才可能得到加速)

(2)IO密集型:O密集型时，大部分线程都阻塞，故需要多配置线程数，CPU核数/1-阻塞系数阻塞系数在0.8至0.9之间。例如4核，取个乐观值0.9，可达到40个线程左右

------------------------------------------------------------------------

--------------------------------

阿里巴巴开发手册上:出自于生产时间来说:

1,线程资源必须通过线程池提供,不能够在应用中自行创建线程;

2,线程池不允许使用Executors去创建,而是使用ThreadPoolExecutor的方式,

这样可以明确线程池的规则,规避资源耗尽的风险;

---------------------------

SpringBoot 自定义线程池:

1,application.yml配置:

task:

pool:

corePoolSize:5#设置核心线程数

maxPoolSize:20#设置最大线程数

keepAliveSeconds:300#设置线程活跃时间（秒）

queueCapacity:50#设置队列容量

2,线程池配置属性类:

importorg.springframework.boot.context.properties.ConfigurationProperties;

/**

* 线程池配置属性类

@ConfigurationProperties(prefix ="task.pool")

publicclassTaskThreadPoolConfig{

privateintcorePoolSize;

privateintmaxPoolSize;

privateintkeepAliveSeconds;

privateintqueueCapacity;

...getter and setter methods...

}

3,启动类上加上异步支持:

@EnableAsync

@EnableConfigurationProperties({TaskThreadPoolConfig.class} )// 开启配置属性支持

4,自定义线程池:

/**

* 创建线程池配置类

@Configuration

public class TaskExecutePool {

@Autowired

private TaskThreadPoolConfig config;

/**

* 1.这种形式的线程池配置是需要在使用的方法上面@Async("taskExecutor"),

* 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池

* 3.所以如果加@Async注解但是不指定使用的线程池，又想自己定义线程池那么就可以重写spring默认的线程池

* 4.所以第二个方法就是重写默认线程池

* 注意：完全可以把线程池的参数写到配置文件中

@Bean

public Executor taskExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

//核心线程池大小

executor.setCorePoolSize(config.getCorePoolSize());

//最大线程数

executor.setMaxPoolSize(config.getMaxPoolSize());

//队列容量

executor.setQueueCapacity(config.getQueueCapacity());

//活跃时间

executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

//线程名字前缀

executor.setThreadNamePrefix("TaskExecutePool-");

// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 等待所有任务结束后再关闭线程池

executor.setWaitForTasksToCompleteOnShutdown(true);

executor.initialize();

return executor;

}

测试:

import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

/**

* @author qijx

@Api(description = "测试控制类11111")

@RestController

@RequestMapping("/threadPoolController1")

public class ThreadPoolController1 {

@Autowired

private ThreadPoolService1 threadPoolService;

@ApiOperation(value = "测试方法")

@ResponseBody

@RequestMapping(value = "/test",method = RequestMethod.GET)

public String threadPoolTest() {

threadPoolService.executeAsync();

return "hello word!";

}

第二种方法:重写springboot线程池:

* 原生(Spring)异步任务线程池装配类，实现AsyncConfigurer重写他的两个方法，这样在使用默认的

* 线程池的时候就会使用自己重写的

@Slf4j

@Configuration

public class NativeAsyncTaskExecutePool implements AsyncConfigurer{

//注入配置类

@Autowired

TaskThreadPoolConfig config;

@Override

public Executor getAsyncExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

//核心线程池大小

executor.setCorePoolSize(config.getCorePoolSize());

//最大线程数

executor.setMaxPoolSize(config.getMaxPoolSize());

//队列容量

executor.setQueueCapacity(config.getQueueCapacity());

//活跃时间

executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

//线程名字前缀

executor.setThreadNamePrefix("NativeAsyncTaskExecutePool-");

// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 等待所有任务结束后再关闭线程池

executor.setWaitForTasksToCompleteOnShutdown(true);

executor.initialize();

return executor;

}

/**

* 异步任务中异常处理

* @return

@Override

public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

return new AsyncUncaughtExceptionHandler() {

@Override

public void handleUncaughtException(Throwable arg0, Method arg1, Object... arg2) {

log.error("=========================="+arg0.getMessage()+"=======================", arg0);

log.error("exception method:"+arg1.getName());

}

};

}

测试:

/**

* @author qijx

@Service

public class ThreadPoolService2 {

private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService2.class);

/**

* @Async该注解不需要在指定任何bean

@Async

public void executeAsync() {

logger.info("start executeAsync");

try {

System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());

Thread.sleep(1000);

} catch (Exception e) {

e.printStackTrace();

}

logger.info("end executeAsync");

}

------------------------------------

我要面试了，给些java面试基础问题，在线等

一、Java基础知识

1.Java有那些基本数据类型，String是不是基本数据类型，他们有何区别。

2.字符串的操作：

写一个方法，实现字符串的反转，如：输入abc，输出cba

写一个方法，实现字符串的替换，如：输入bbbwlirbbb，输出bbbhhtccc。

3.数据类型之间的转换

如何将数值型字符转换为数字（Integer，Double）

如何将数字转换为字符

如何取小数点前两位，并四舍五入。

4.日期和时间

如何取得年月日，小时分秒

如何取得从1970年到现在的毫秒数

如何获取某个日期是当月的最后一天

如何格式化日期

5.数组和集合

6.文件和目录（I/O）操作

如何列出某个目录下的所有文件

判断一个文件或目录是否存在

如何读写文件

7.Java多态的实现（继承、重载、覆盖）

8.编码转换，怎样实现将GB2312编码的字符串转换为ISO-8859-1编码的字符串。

9.Java中访问数据库的步骤，Statement和PreparedStatement之间的区别。

10.找出下列代码可能存在的错误，并说明原因：

二、JSPServlet技术

1.描述JSP和Servlet的区别、共同点、各自应用的范围

2.在Web开发中需要处理HTML标记时，应做什么样的处理，要筛选那些字符（ “”）

3.在JSP中如何读取客户端的请求，如何访问CGI变量，如何确定某个Jsp文件的真实路径。

4.描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理。

5.列出Jsp中包含外部文件的方式，两者有何区别。

6.说明Jsp中errorPage的作用，应用范围。

7.介绍在Jsp中如何使用JavaBeans。

8.简单介绍JSP的标记库

9.Jsp和Servlet中的请求转发分别如何实现。

三、J2EE相关知识

1.介绍J2EE、J2SE、J2SE的区别。

2.J2EE是一种技术还是一种平台，他提供了那些技术。

3.什么是Application Server，它有什么功能和优点。

4.简单介绍连接池的优点和原理。

5.Web.xml的作用

四、其他

1.Web安全性的考虑（表单验证、浏览器Basic方式的验证，应用程序的安全性，SSL，代码考虑）

2.简单介绍您所了解的MVC。

3.简单介绍所了解的XML。

4.文档和编码规范

5.Java中的分页、效率考虑。

6.简单介绍您所了解的structs。

.xml在项目中的作用

2.s-EJB 与 e-EJB的区别

3.会话面的作用

4.cmp与bmp的优缺点

5.j2me程序的必需的几个部分

6.c/s与b/s的区别

7.构建一个connect pool,然后再调用它，

8.j2ee平台与dotnet平台的区别

9.ejb的life cycle

10.session bean 和 entity bean的区别

11.ejb中的transaction机制

12.synchronized (生产者和消费）

13.String 和 StringBuffer

14.Serializable

15.MVC （Struts的工作流程）

16.什么是MDA

17.tcp与udp的区别

18.链表与散列表和数组的区别

19.堆和栈的区别

20.ejb的分类及区别

21.你对现在软件业以及国内软件业的看法

22.谈谈java多线程

23.谈谈文件加密技术

24.软件开发生命周期

25.路由协议种类及特点

26.java的awt和swing组件的GUI设计的关键

27.对于java流的认识

28.简单描述一下awt与swing区别。

29.简述java编程中事件处理模式。

30.你编写过applet吗？applet的安全权限如何？试列举java application或者applet中与servlet/jsp通信可以采用的方式。

31.简述逻辑操作(如,|)与条件操作(如,||)的区别。

32.简述 Java Server Page 和 Servlet 的联系和区别。

33.简述synchronized和java.util.concurrent.locks.Lock的异同？

34.EJB规范规定EJB中禁止的操作有哪些？

35.java除了8种基本类型外，在虚拟机里还有哪一种，有什么作用?

36.除了使用new关键字创建对象意外，试列举另外三种以上创建实例的方式?

37.classloader中，JDK的API、Classpath中的同web-inf中的class加载方式有什么区别？

38.列举三种以上垃圾回收算法，并比较其优缺点？

39.编写代码实现一个线程池

40.描述一下JVM加载class文件的原理机制?

41.试举例说明一个典型的垃圾回收算法？

42.请用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来.

43.请写一个java程序实现线程连接池功能？

44.给定一个C语言函数，要求实现在java类中进行调用。

45.如何获得数组的长度？

46.访问修饰符“public/private/protected/缺省的修饰符”的使用

47.用关键字final修饰一个类或者方法时，有何意义？

48.掌握类和对象的概念，掌握面向对象编程的本质

49.静态变量和静态方法的意义，如何引用一个类的静态变量或者静态方法？

50.JAVA语言如何进行异常处理，关键字：thorws,throw,try,catch,finally

51.Object类(或者其子类)的finalize()方法在什么情况下被调用？

52.一个“.java”原文件中是否可以包括多个类（不是内部类）？

53.掌握内部类和接口的概念

54.StringTokenizer类的使用

55.数据结构，如何遍历List中的元素？

如果要按照键值保存或者访问数据，使用什么数据结构？

要掌握Collection相关的接口和类的使用

56.使用StringBuffer类与String类进行字符串连接时有何区别？

57.调用Thread类的destroy()方法有什么后果？

58.多线程，用什么关键字修饰同步方法？stop()和suspend()方法为何不推荐使用？

59.使用socket建立客户端与服务器的通信的过程

60.JAVA语言国际化应用，Locale类，Unicode

61.描述反射机制的作用

62.如何读写一个文件？

63.在图形界面中，一个按钮如何处理鼠标点击事件？

64.在图形界面中，一个表格，如何实现编辑单元格时弹出下拉框？

65.如何加载图片？

66.什么是模态对话框？

67.阐述MVC的概念

68.GUI布局管理器的使用，FlowLayout,BorderLayout,GridBagLayout

69.如何构造一棵树？选择树的一个节点时，如何得到这个节点？

70.向编辑框中输入字符时，如何控制只输入整数？

71.描述使用JDBC连接数据库的过程

72.EJB分为几类？什么是BMP,CMP?

73.什么是JNDI?

74.ADO是什么?ActiveX数据对象,是一个应用级程序接口.

75.四种JDBC方式?目前的版本?

76.EJB有哪几种?区别是什么?

77.JavaBean与EJB有什么区别?

78.软件开发生命周期有哪几个阶段?

79.软件开发有哪些因素?

80.软件开发中如何进行版本控制?

81.UML中,类视图如何表示类中的继承与聚合?

82.客户端游标与服务器端游标的区别?

83.动态游标与静态游标的区别?

84.dotnet由哪几个基本框架组成?

85.Oracle中SGA是什么?

86.web servers是什么?

87.UNIX中QT是什么意思?

88.在软件开发生命周期中的哪个阶段开始测试?

89.dotnet与J2EE的比较?

90.什么是ActiveX?

91.Java中IDL是什么?

92.ISO9000和CMM是什么?IS09000和CMM(软件能力成熟度模型)认证是国际上通用的软件质量评估方法.CMM的五个成熟度等级。

java的面试题有哪些？

正如圈内的大佬所说的那样，基础很重要。浙江优就业的老师帮你总结一下。

常见的面试题有：

安卓图片加载后一直在手机如何优化?

解释一下安卓中SharedPreferences类?

客户端和服务端如何收发信息?

activity里如何发起http请求?

安卓UI线程调用sleep?

static类如何回收?

接口和抽象类

JVM垃圾回收算法

如何区分哪些是老年代对象?

线程池

线程终止

设计模式

单例

JDBC

Runnable

run()

start()

区别?

Socket

静态代码块和构造器的执行顺序

final的map能否修改?

String

StringBuffer

StringBuild区别?

内存泄露?

ArraryList

LinkedList

HashMap原理

linux常用命令

查看进程PS

redis相关?

运行时异常

一个对象为空，怎么进行处理?

泛型

哪里用到?什么好处

对数据库进行一些操作，mybatis要进行哪些操作?

为什么Java是跨平台?

匿名内部类能不能有外部内的接口?(反正跟匿名内部类有关)?

@Test

测试用例

干嘛

如何获取http的参数?

Controller的参数设置,为什么是单例的?

@autowired装载一个类，构造器里能不能直接调用这个类

spring和springmvc区别?

springmvc跨域?

锁的种类等

望采纳！

面试题：线程池有几种实现方式，线程池的七大参数有哪些？

在Java编码的过程中，我们经常会创建一个线程来提高程序的执行效率，虽然这样实现起来很方便，但是会有一个问题：如果并发的线程数多，并且每个线程都是执行一个时间很短的任务就结束了，这样会造成频繁的创建和销毁线程从而导致降低系统的效率。

那么问题来了，有没有办法可用复用创建好的线程呢，也就是线程执行完一个任务后，不被销毁，继续执行其他的任务？

在Java可以通过线程池来实现这样的效果。

下面从三个方面和大家一起来探讨一下Java线程池相关的内容。

1.Java中的ThreadPoolExecutor类。

2.Java中4种线程池的使用。

3.Java线程池常用参数如何设置。

一、Java中的ThreadPoolExecutor类

A.ThreadPoolExecutor的重要参数

1.corePoolSize：核心线程数

核心线程会一直存活，及时没有任务需要执行。

当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理。

设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭。

2.queueCapacity：任务队列容量（阻塞队列）

当核心线程数达到最大时，新任务会放在队列中排队等待执行。

3.maxPoolSize：最大线程数

当线程数=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务。

当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常。

4.keepAliveTime：线程空闲时间

当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize。

如果allowCoreThreadTimeout=true，则会直到线程数量=0。

5.allowCoreThreadTimeout：允许核心线程超时

6.rejectedExecutionHandler：任务拒绝处理器。

B.ThreadPoolExecutor执行过程

1.当线程数小于核心线程数时，创建线程。

2.当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。

3.当线程数大于等于核心线程数，且任务队列已满。(1)若线程数小于最大线程数，创建线程。(2)若线程数等于最大线程数，抛出异常，拒绝任务。

二、Java中4种线程池

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

关于java线程池面试题和线程线程池面试题的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：java线程池面试题