java怎么查看线程池是否满?Java线程池如何创建?

在实际开发过程中,在线程池使用过程中可能会遇到各方面的故障,如线程池阻塞,线程池满了的情况,遇到这些都会让系统无法正常工作,那java怎么查看线程池是否满?下面来我们就来给大家讲解一下。

java怎么查看线程池是否满.jpg

如果你想监控某一个线程池的执行状态,线程池执行类 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工具网。

推荐阅读:

fastjson用什么替代?如何替代?

json格式不支持换行吗?json格式怎么打开?

java怎么写函数?java函数的特点是什么?

推荐内容