java - 如何时不时地查看线程中的值？

Question

我正在用 Java 设计一个监控客户端，它将从 /proc 读取信息。我有一个主类 MonitoringClient 和 ProcParser 类。我的 ProcParser 扩展了 Thread。

我认为这将是实例化许多(四个:cpu、内存、磁盘和网络)ProcParser 对象的好方法，并传递我想要在构造函数中测量的组件之一。然后，在 run 方法中，我在 then 之间切换，每个对象将解析其中之一。代码类似于:

ProcParser pp_Cpu = new ProcParser(UsageType.CPU, 1000, Pid.getPid());
ProcParser pp_Memory = new ProcParser(UsageType.MEMORY, 1000, Pid.getPid());
ProcParser pp_Disk = new ProcParser(UsageType.DISK, 1000, Pid.getPid());
ProcParser pp_Network = new ProcParser(UsageType.NETWORK, 1000, Pid.getPid());

ArrayList<String> cpuData = null;
ArrayList<String> memoryData = null;
ArrayList<String> diskData = null;
ArrayList<String> networkData = null;

pp_Cpu.start();
pp_Memory.start();
pp_Disk.start();
pp_Network.start();

for (;;) {
    if (pp_Cpu.isReady() && pp_Memory.isReady()
&& pp_Disk.isReady() && pp_Network.isReady()) {

        cpuData = pp_Cpu.getUsageData();
        memoryData = pp_Memory.getUsageData();
        diskData = pp_Disk.getUsageData();
        networkData = pp_Network.getUsageData();
    } else {
        sleep(1000); //this does not work. I have to extend to Thread also the main class?
    }
}

如何时不时地查看收集到的值？另外，从 Java 线程的角度来看，我创建线程(每个主要组件一个)的方式是一种好方法吗？提前致谢。

ProcParser 中的 Run 方法。

@Override
    public void run() {
        if ((this.usageType == null) || (this.sleepTime < 0) || (this.processPid < 0)) {
            throw new IllegalArgumentException();
        }

        //Forever sleep and gather the usage values
        for (;;) {
            this.ready = false;
            switch (this.usageType) {
                case CPU:
                    this.gatherCpuUsage();
                    this.ready = true;
                    break;
                case MEMORY:
                    this.gatherMemoryUsage(this.processPid);
                    this.ready = true;
                    break;
                case DISK:
                    this.gatherDiskUsage();
                    break;
                case NETWORK:
                    this.gatherNetworkUsage();
                    break;
                case PARTITION:
                    this.gatherPartitionUsage();
                    break;
                default:
                    break;
            }
        }
    }

Answer 1

How do I peek the gathered values time to time?

我假设您的 ProcParser 线程在后台运行，从 /proc 读取 CPU 数据(例如)，然后 hibernate 。您可能需要考虑使用 AtomicReference 。类似于以下内容:

 private final AtomicReference<List<String>> cpuDataReference =
     new AtomicReference<List<String>>();
 ...

 ProcParser pp_Cpu =
     new ProcParser(UsageType.CPU, 1000, Pid.getPid(), cpuDataReference);
 ...

 // in your `ProcParser`
 List<String> cpuDataList = new ArrayList<String>();
 // read in the /proc files into the list
 ...
 // save it in the AtomicReference passed into the constructor
 dataReference.set(cpuDataList);

 // other threads could then get the latest list
 List<String> cpuDataList = cpuDataReference.get();

如果您担心消费者更改列表，您可能需要set()一个不可修改的列表。

Is the way I'm creating the threads (one for each main component) a good approach from the Java Threading point of view?

如果这不是一个练习，我会说您不需要线程复杂性——它不会给您带来太多好处。选择哪些任务需要线程、创建多少个线程等是在这些情况下需要做出的关键决策。

一般来说，您应该考虑让 ProcParser 实现 Runnable 而不是扩展 Thread，然后说 new Thread(new ProcParser(. ..))。这是推荐的模式。您还应该始终考虑使用 Executors 类返回的 ExecutorService 类。这些线程池接管线程的管理并使您的代码更加简单。