在实际开发过程中，在线程池使用过程中可能会遇到各方面的故障，如线程池阻塞，线程池满了的情况，遇到这些都会让系统无法正常工作，那java怎么查看线程池是否满?下面来我们就来给大家讲解一下。
如果你想监控某一个线程池的执行状态，线程池执行类 ThreadPoolExecutor 也给出了相关的 API, 能实时获取线程池的当前活动线程数、正在排队中的线程数、已经执行完成的线程数、总线程数等。
根据数据集合的大小，所开线程的数量，计算每个线程需要执行查询的数据量。
计算出SQL语句中每个查询的起始位置和结束位置下标。
每个线程，查询各自的范围内的数据。
public void queryByThread()
{
// 数据集合大小，由调用者自己指定
int listSize = 100;
// 开启的线程数
int runSize = 20;
// 一个线程处理数据条数，如果库中有100条数据，开启20个线程，那么每一个线程执行的条数就是5条
int count = listSize / runSize; //5
// 创建一个线程池，数量和开启线程的数量一样
ExecutorService executor = CreateThreadUtil.createThread(runSize);
// 计算sql语句中每个分页查询的起始和结束数据下标
// 循环创建线程
//此处调用具体的查询方法
System.out.println("开始查询");
for (int i = 0; i < runSize; i++)
{
int index = i * count;
int num = count;
executor.execute(new Runnable()
{
@Override
public void run()
{
try
{
//查询的结果如何保存下来，会不会存在覆盖的问题
System.out.println("每次查询的下标:" + index + ",条数:" + num);
ListtextList = textMapper.queryByThread(index, num);
//这里做处理信息的方法
}
catch (Exception e)
{
System.out.println("查询失败" + e);
}
}
});
}
// 执行完关闭线程池
executor.shutdown();
}创建线程池：
package com.klay.service.impl;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class CreateThreadUtil
{
public static ThreadPoolExecutor createThread(int runSize)
{
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("测试信息")
.build(); //创建线程工厂
//创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(runSize
, runSize
, 0 L
, TimeUnit.MILLISECONDS
, new LinkedBlockingQueue < > (1024)
, namedThreadFactory
, new ThreadPoolExecutor.AbortPolicy());
return executor;
}
}Java线程池如何创建?
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1.newCachedThreadPool 这里的线程池是无限大的，当一个线程完成任务之后，这个线程可以接下来完成将要分配的任务，而不是创建一个新的线程。
public static void main(String[] args)
{
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++)
{
final int index = i;
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable()
{
public void run()
{
System.out.println(index);
}
});
}
}2.newFixedThreadPool
public static void main(String[] args)
{
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++)
{
final int index = i;
fixedThreadPool.execute(new Runnable()
{
public void run()
{
try
{
System.out.println(index);
Thread.sleep(10);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
});
}
}3.newScheduledThreadPool
public static void main(String[] args)
{
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++)
{
scheduledThreadPool.schedule(new Runnable()
{
public void run()
{
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
}
}4.newSingleThreadExecutor 按顺序来执行线程任务 但是不同于单线程，这个线程池只是只能存在一个线程，这个线程死后另外一个线程会补上。
public static void main(String[] args)
{
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++)
{
final int index = i;
singleThreadExecutor.execute(new Runnable()
{
public void run()
{
/* System.out.println(index);*/
try
{
System.out.println(index);
Thread.sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
});
}
}我们可以利用以上的方法进行java线程池的创建，在创建的过程中，我们需要进行线程池设置，设置不能过大也不能过小，不然就会影响运行!最后大家如果想要了解更多java入门知识，敬请关注奇Q工具网。
推荐阅读：