Java 计算工作线程仍在处理时所用的时间

我无法获取工作线程的处理时间。我有一个线程监视我的工作线程的处理时间，并报告所花费的时间以及有多少工作线程处于处理状态

问题

我的监视线程，总是报告没有处于处理状态的工作线程？我怀疑我的监视线程无法正确评估工作线程

我已经同步了一些获取和记录处理时间和处理状态的方法。这是否足够让我的监视器线程跟踪处理时间，而不进行线程覆盖

iProcessing布尔变量是否应为易失变量

我的工人阶级

public class MyWorker implements Runnable {

    private final int WAIT_INTERVAL = 200;
    private MyService myService;
    private MyProvider myProvider;
    private boolean stopRequested = false;
    private boolean isProcessing; // Flag to indicate the worker is currently processing a message
    private long processingStartTime; //captures when the worker started processing a message
    private Logger logger = new Logger();

public MyWorker(MyService myService, MyProvider myProvider){
        this.myService = myService;
        this.myProvider = myProvider;
        this.isProcessing = false;
        this.processingStartTime = -1;
    }

    public void setStopRequested() {
        stopRequested = true;
    }


    private synchronized void recordProcessingStart(long start){
        isProcessing = true;
        processingStartTime = start;
    }

    private synchronized void recordProcessingStop(){
        isProcessing = false;
        processingStartTime = -1;
    }

    public synchronized boolean isProcessing(){
        return isProcessing;
    }

    public synchronized long getProcessingStartTime(){
        return processingStartTime;
    }

    @Override
    public void run() {

        while (!stopRequested) {
            boolean processingMessage = false;
            List<Message> messages = myProvider.getPendingMessages();
            if (messages.size() != 0) {
                logger.log("We have " + messages.size() + " messages");
                recordProcessingStart(System.currentTimeMillis());
                for (Message message : messages) {
                    processMessage(messages);
                }
                recordProcessingStop();
            }

            if (!(processingMessage || stopRequested)) {
                // this is to stop the thread from spinning when there are no messages
                try {
                    Thread.sleep(WAIT_INTERVAL);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void processMessage(Message messages){
        myService.process(messages);
    }
}

公共类MyWorker实现可运行{
专用最终整数等待间隔=200；
私人MyService-MyService；
私人MyProvider MyProvider；
私有布尔stopRequested=false；
private boolean isProcessing；//指示工作进程当前正在处理消息的标志
private long processingStartTime；//捕获工作进程开始处理消息的时间
专用记录器=新记录器（）；
公共MyWorker（MyService MyService，MyProvider MyProvider）{
this.myService=myService；
this.myProvider=myProvider；
this.isProcessing=false；
this.processingStartTime=-1；
}
公共无效setStopRequested（）{
stopRequested=true；
}
专用同步的void recordProcessingStart（长启动）{
isProcessing=true；
processingStartTime=开始；
}
私有同步的void recordProcessingStop（）{
isProcessing=false；
processingStartTime=-1；
}
公共同步布尔值isProcessing（）{
返回处理；
}
公共同步长getProcessingStartTime（）{
返回处理开始时间；
}
@凌驾
公开募捐{
而（！stopRequested）{
布尔处理消息=false；
List messages=myProvider.getPendingMessages（）；
如果（messages.size（）！=0）{
logger.log（“我们有”+消息.size（）+“消息”）；
recordProcessingStart（System.currentTimeMillis（））；
用于（消息：消息）{
processMessage（消息）；
}
recordProcessingStop（）；
}
如果（！（处理消息| |停止请求））{
//这是为了在没有消息时阻止线程旋转
试一试{
线程睡眠（等待间隔）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
}
私有void processMessage（消息消息）{
进程（消息）；
}
}

WorkerManager类

public class WorkerManager implements Runnable {

    private MyWorker[] workers;
    private int workerCount;
    private boolean stopRequested;
    private ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
    private Logger logger = new Logger();

    public WorkerManager(int count) {
        this.workerCount = count;
    }

    @Override
    public void run() {
        stopRequested = false;
        boolean managerStarted = false;

        while (!stopRequested) {
            if (!managerStarted) {
                workers = new MyWorker[workerCount];
                for (int i = 0; i < workerCount; i++) {
                    final Thread workerThread = new Thread(workers[i], "Worker-" + (i + 1));
                    workerThread.start();
                }
                startProcessMonitoringThread();
                managerStarted = true;
            }
        }
    }

    public void stop() {
        stopRequested = true;
    }

    public void cleanUpOnExit() {
        for (MyWorker w : workers) {
            w.setStopRequested();
        }
        stopProcessMonitoringThread();
    }

    private void startProcessMonitoringThread(){

        scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.scheduleWithFixedDelay( new WorkerMonitorThread(workers), 1, 1, TimeUnit.MINUTES);
        logger.info("Monitoring of worker threads initialized ...");
    }

    private void stopProcessMonitoringThread(){
        scheduledExecutorService.shutdown();
        logger.info("Successfully shutdown worker monitoring thread ...");
    }


    private class WorkerMonitorThread implements Runnable{

        private MyWorker[] workers;
        WorkerMonitorThread(MyWorker workers[]){
            this.workers = workers;

        }

        @Override
        public void run() {
            String trackingId = "["+ UUID.randomUUID().toString() + "] - ";
            logger.info(trackingId + "Calculating processing times of worker threads ...");

            StringBuilder sb = new StringBuilder();
            int totalWorkersInProcess = 0;
            for (int i = 0; i < workerCount; i++) {
                MyWorker worker = workers[i];
                if(worker.isProcessing()){
                    totalWorkersInProcess++;
                    long startTime = worker.getProcessingStartTime();
                    long currentTime = System.currentTimeMillis();
                    long duration = currentTime - startTime;
                    sb.append(trackingId + "Worker-" + (i + 1) + " has been processing for the last : " + duration + " ms");
                }
            }
            sb.append(trackingId + "Total worker(s) in progress : " + totalWorkersInProcess);
            logger.info(sb.toString());
        }
    }
}

公共类WorkerManager实现可运行{
私人雇员[]工人；
私人内部工人计数；
请求私有布尔值；
私有ScheduleXecutorService ScheduleXecutorService=Executors.NewsingleThreadScheduleXecutor（）；
专用记录器=新记录器（）；
公共WorkerManager（整数计数）{
this.workerCount=计数；
}
@凌驾
公开募捐{
stopRequested=false；
布尔值managerStarted=false；
而（！stopRequested）{
如果（！managerStarted）{
工人=新的我的工人[工人计数]；
对于（int i=0；i

您还没有创建工人

查看WorkerManager运行方法的代码：

            workers = new MyWorker[workerCount]; // Create an array of MyWorker, but each element of the array is null.
            for (int i = 0; i < workerCount; i++) {
                final Thread workerThread = new Thread(workers[i], "Worker-" + (i + 1)); // <-- Creates a thread and pass a null MyWorker.
                workerThread.start(); // NullPointers are coming on the other thread.
            }

然后，创建

    public WorkerManager(int count, MyService myService, MyProvider myProvider) {
        this.workerCount = count;
        this.myService = myService;
        this.myProvider = myProvider;
    }

            workers = new MyWorker[workerCount];
            for (int i = 0; i < workerCount; i++) {
                workers[i] = new MyWorker(myService, myProvider);
            }