在程序开发中我们经常会使用到很多线程去做不同的业务，我们怎么能方便的管理这些线程呢？是否我们希望我们创建的线程能够一直运行下去，知道程序退出？在这里我们使用一个监控线程的概念。
 
我们可以定义一个线程继承自Thread类，在其中定义一个Map集合，用于存放我们需要管理的线程；当我们需要对某个线程进行操作时，我们就可以根据他的key值获取到；
 
private HashMap<String, Thread> threads2Watch = new HashMap<String, Thread>();
 
在run方法中，我们写一个循环，让此线程一直运行下去，并利用sleep方法，让其停顿一段时间；
 
while (true) {
            try {
                sleep(1 * 60 * 1000);
            } catch (InterruptedException e) {
                DebugLog.logger.error("Exception!!", e);
                continue;
            }
        }
 
注意这里的catch中加入了一个continue；即使此次sleep发生了异常，while循环仍然可以运行下去；不会对整个线程造成影响；
 
在while()循环中，我们就可以写自己管理线程的业务方法了，比如遍历整个map集合，获取当前线程的转态，如果线程已经结束，我们就从新开启一个这样的线程，并把它加入map集合中；
 
通过以上的这种做法，我们可以让我们自己程序中想要一直运行的线程一直运行下去，这种线程尤其适合在频繁监听某一网络端口，网络状态，某些值的变化是很重要的；
 
通过这种思想，我们可以根据自己需要扩展自己的功能；

MinerMonitorThread.java 监控线程
 
package com.iteye.injavawetrust.miner;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 监控线程
 * @author Administrator
 *
 */
public class MinerMonitorThread extends Thread {
	
	private static final Log LOG = LogFactory.getLog(MinerMonitorThread.class);
	
	public static volatile boolean done = false;

	@Override
	public void run() {
		while(!done){
			synchronized (this) {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if (MinerQueue.unVisitedIsEmpty()
						&& MinerQueue.waitingMiseringIsEmpty()
						&& MinerQueue.storeIsEmpty()) {
					done = true;
					MinerThreadPool.shutdown();
					LOG.info("MinerMonitorThread程序结束。。。。。。当前线程[" + Thread.currentThread().getName() + "]");
					long endTime = System.currentTimeMillis();
					LOG.info("MinerMonitorThread已经访问队列URL大小[" + MinerQueue.getUrlSetSize() + "]当前线程[" + Thread.currentThread().getName() + "]");
					LOG.info("用时[" + MinerUtil.msToss(endTime - MinerUtil.starTime) + "]当前线程[" + Thread.currentThread().getName() + "]");
				}
			}
		}
	}

}
 
 
 
返回列表
 
 

 
 
 
  
Java线程状态
 
  
线程的五种状态
 
  
* 新建：new（时间很短）
 
  
* 运行：runnable
 
  
* 等待：waitting(无限期等待),timed waitting(限期等待)
 
  
* 阻塞：blocked
 
  
* 结束：terminated（时间很短）
 
  
 
  
Jvm监控工具
 
  
一、jstack
 
  
介绍：
 
  
jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息。
如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式：jstack [-l] pid
如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。
另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack
 

Java 监控线程池所有任务是否执行完毕
 
场景引入
 
 
 
在最近的工作中遇到一个需要批量生产百万数据并写入数据库的需求，先通过单线程的方式去实现，但是感觉效率一般，然后通过多线程的方式去改进，但是遇到下面的问题：
 
 
生成数据的时候，每生成一条数据，就将数据丢入到集合中进行缓存，当集合中的数据量达到 500 的时候，就进行一次数据库写入操作，并清空集合。
 
 
那么当我生成的数据量为 1200 的时候，就会出现最后 200 条没有写入到数据库的问题
 
 
那么要解决这个问题，就要知道线程池的任务什么时候执行完毕，网上找了很多方法如：
 
 
方案一 - 直接调用是否终止的方法
 
 
executor.isTerminated()
 
 
方案二 - 判断活跃线程数
 
 
executor.getActiveCount() == 0
 
 
方案三 - 设置一个较长的等待时间
 
 
executor.awaitTermination(10000, TimeUnit.SECONDS);
 
 
但是都没有达到我的目的（也有可能是我使用的姿势不对）
 
 
最后尝试了下面的方法
 
 
功能实现
 
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class ThreadPoolTest {

    static List<Integer> TEMP_LIST = new ArrayList<>(10);

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Random random = new Random();
        int count = random.nextInt(100);
        for (int i = 0; i < count; i++) {
            int finalI = i;
            executorService.execute(() -> {
                addToTemp(finalI * 2, false);
                try {
                    Thread.sleep(random.nextInt(1000 * 2));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 监控线程执行情况
        monitor((ThreadPoolExecutor) executorService);
        // 最后一次数据插入
        addToTemp(null, true);
        System.out.println("结束");
    }
    
    /**
     * 添加数据到缓存
     *
     * @Author: Neo
     * @Date: 2019/12/19 21:46
     * @Version: 1.0
     */
    public static synchronized void addToTemp(Integer data, boolean focus) {
        if (null != data) {
            TEMP_LIST.add(data);
        }

        if (CollectionUtils.isNotEmpty(TEMP_LIST) && (CollectionUtils.size(TEMP_LIST) >= 10 || focus)) {
            // 模拟数据库写入
            log.info("执行一次插入，数据量：{}", CollectionUtils.size(TEMP_LIST));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            TEMP_LIST.clear();
        }
    }
    
    /**
     * 监控线程执行情况
     * 一直阻塞到线程任务执行完毕
     *
     * @Author: Neo
     * @Date: 2019/12/19 21:09
     * @Version: 1.0
     */
    public static void monitor(ThreadPoolExecutor executor) {
        
        while (!isTerminated(executor)) {
            try {
                int queueSize = executor.getQueue().size();
                int activeCount = executor.getActiveCount();
                long completedTaskCount = executor.getCompletedTaskCount();
                long taskCount = executor.getTaskCount();

                log.info("当前排队线程数：{}，当前活动线程数：{}，执行完成线程数：{}，总线程数：{}", queueSize, activeCount, completedTaskCount, taskCount);

                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 线程池任务是否执行完毕
     *
     * @Author: Neo
     * @Date: 2019/12/19 21:11
     * @Version: 1.0
     */
    public static boolean isTerminated(ThreadPoolExecutor executor) {
        return executor.getQueue().size() == 0 && executor.getActiveCount() == 0;
    }
}