import oshi.software.os.OSProcess; //导入依赖的package包/类
private double getProcessRecentCpuUsage() {
    double output = 0d;
    HardwareAbstractionLayer hal = si.getHardware();
    OperatingSystem os = si.getOperatingSystem();
    OSProcess p = os.getProcess(os.getProcessId());

    if (cpuTime != 0) {
        double uptimeDiff = p.getUpTime() - uptime;
        double cpuDiff = (p.getKernelTime() + p.getUserTime()) - cpuTime;
        output = cpuDiff / uptimeDiff;
    } else {
        output = ((double) (p.getKernelTime() + p.getUserTime())) / (double) p.getUserTime();
    }

    // Record for next invocation
    uptime = p.getUpTime();
    cpuTime = p.getKernelTime() + p.getUserTime();
    return output / hal.getProcessor().getLogicalProcessorCount();
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
public static Process create(OSProcess process, GlobalMemory memory) {
    return new Process(process.getName(),
            process.getPath(),
            process.getCommandLine(),
            process.getUser(),
            process.getUserID(),
            process.getGroup(),
            process.getGroupID(),
            process.getState(),
            process.getProcessID(),
            process.getParentProcessID(),
            process.getThreadCount(),
            process.getPriority(),
            process.getVirtualSize(),
            process.getResidentSetSize(),
            100d * process.getResidentSetSize() / memory.getTotal(),
            process.getKernelTime(), process.getUserTime(),
            process.getUpTime(),
            100d * (process.getKernelTime() + process.getUserTime()) / process.getUpTime(),
            process.getStartTime(),
            process.getBytesRead(),
            process.getBytesWritten());
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
/**
 * Prints the processes.
 *
 * @param os the os
 * @param memory the memory
 */
private static void printProcesses(OperatingSystem os, GlobalMemory memory) {
  oshi.add("Processes: " + os.getProcessCount() + ", Threads: " + os.getThreadCount());
  // Sort by highest CPU
  List<OSProcess> procs = Arrays.asList(os.getProcesses(5, ProcessSort.CPU));

  oshi.add("   PID  %CPU %MEM       VSZ       RSS Name");
  for (int i = 0; i < procs.size() && i < 5; i++) {
    OSProcess p = procs.get(i);
    oshi.add(String.format(" %5d %5.1f %4.1f %9s %9s %s%n", p.getProcessID(),
        100d * (p.getKernelTime() + p.getUserTime()) / p.getUpTime(),
        100d * p.getResidentSetSize() / memory.getTotal(),
        FormatUtil.formatBytes(p.getVirtualSize()),
        FormatUtil.formatBytes(p.getResidentSetSize()), p.getName()));
  }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
private void update() {
    List<OSProcess> procs = Arrays.asList(os.getProcesses(10, OperatingSystem.ProcessSort.CPU));
    for (OSProcess process : procs) {
        ProcessBean bean = null;
        if(processList.getItems().size() <= procs.indexOf(process)) {
            bean = beanManager.create(ProcessBean.class);
            processList.getItems().add(bean);
        } else {
            bean = processList.getItems().get(procs.indexOf(process));
        }
        bean.setProcessID(new Integer(process.getProcessID()).toString());
        bean.setCpuPercentage(format.format(100d * (process.getKernelTime() + process.getUserTime()) / process.getUpTime()));
        bean.setMemoryPercentage(format.format(100d * process.getResidentSetSize() / memory.getTotal()));
        bean.setName(process.getName());
    }
    asyncServerRunner.execute(new Runnable() {
        @Override
        public void run() {
            sessionExecutor.runLaterInClientSession(() -> update());
        }
    });
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Nullable
static ProcessResourceConsumption getProcessResourceConsumptionInternal(
    @Nullable OSProcess process) {
  if (process == null) {
    return null;
  }
  return ProcessResourceConsumption.builder()
      .setMemResident(process.getResidentSetSize())
      .setMemSize(process.getVirtualSize())
      .setCpuReal(process.getUpTime())
      .setCpuUser(process.getUserTime())
      .setCpuSys(process.getKernelTime())
      .setCpuTotal(process.getUserTime() + process.getKernelTime())
      .setIoBytesRead(process.getBytesRead())
      .setIoBytesWritten(process.getBytesWritten())
      .setIoTotal(process.getBytesRead() + process.getBytesWritten())
      .build();
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
private void setupDataUnix(OperatingSystem.ProcessSort sort) {
    OSProcess[] processes = services.processorService.getProcessesList(sort);
    data = new String[processes.length][5];

    for(int i = 0; i < processes.length; i++) {
        // path, uptime, pid, name
        data[i][0] = processes[i].getName();
        data[i][1] = Integer.toString(processes[i].getProcessID());
        data[i][2] = Long.toString(processes[i].getResidentSetSize() / (1024 * 1024)) + " MB";
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Before
public void setUp() {

    process = new Process(
            "name",
            "path",
            "commandLine",
            "user",
            "123",
            "group",
            "1233",
            OSProcess.State.RUNNING,
            100,
            99,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0);
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
private OSProcess getProcess(int pid) throws DeviceNotFoundException {
    OSProcess process = operatingSystem.getProcess(pid);
    if (process == null) {
        throw new DeviceNotFoundException("Error while getting information for process with PID " + pid);
    }
    return process;
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public StringType getProcessName(int pid) throws DeviceNotFoundException {
    if (pid > 0) {
        OSProcess process = getProcess(pid);
        String name = process.getName();
        return new StringType(name);
    } else {
        return null;
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public DecimalType getProcessCpuUsage(int pid) throws DeviceNotFoundException {
    if (pid > 0) {
        OSProcess process = getProcess(pid);
        double cpuUsageRaw = (process.getKernelTime() + process.getUserTime()) / process.getUpTime();
        BigDecimal cpuUsage = getPercentsValue(cpuUsageRaw);
        return new DecimalType(cpuUsage);
    } else {
        return null;
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public DecimalType getProcessMemoryUsage(int pid) throws DeviceNotFoundException {
    if (pid > 0) {
        OSProcess process = getProcess(pid);
        long memortInBytes = process.getResidentSetSize();
        long memoryInMB = getSizeInMB(memortInBytes);
        return new DecimalType(memoryInMB);
    } else {
        return null;
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public StringType getProcessPath(int pid) throws DeviceNotFoundException {
    if (pid > 0) {
        OSProcess process = getProcess(pid);
        String path = process.getPath();
        return new StringType(path);
    } else {
        return null;
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public DecimalType getProcessThreads(int pid) throws DeviceNotFoundException {
    if (pid > 0) {
        OSProcess process = getProcess(pid);
        int threadCount = process.getThreadCount();
        return new DecimalType(threadCount);
    } else {
        return null;
    }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
/** Gets resource consumption of the process with the given pid. */
@Nullable
public ProcessResourceConsumption getProcessResourceConsumption(long pid) {
  try {
    OperatingSystem os = OSHI.getOperatingSystem();
    OSProcess process = os.getProcess((int) pid);
    return getProcessResourceConsumptionInternal(process);
  } catch (Exception ex) {
    // do nothing
    return null;
  }
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
public Node add(OSProcess info) {
  Node node = getOrCreate(info.getProcessID());
  if (node.info == null) {
    node.info = info;
  }
  Node parent = getOrCreate(info.getParentProcessID());
  parent.addChild(node);
  return node;
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
@Override
public Optional<Process> getProcessByPid(int pid) {
    return Optional
            .of(operatingSystem.getProcess(pid))
            .map((OSProcess p) -> Process.create(p, hal.getMemory()));
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
public Process(String name,
               String path,
               String commandLine,
               String user,
               String userID,
               String group,
               String groupID,
               OSProcess.State state,
               int processID,
               int parentProcessID,
               int threadCount,
               int priority,
               long virtualSize,
               long residentSetSize,
               double memoryPercent,
               long kernelTime,
               long userTime,
               long upTime,
               double cpuPercent,
               long startTime,
               long bytesRead,
               long bytesWritten) {
    this.name = name;
    this.path = path;
    this.commandLine = commandLine;
    this.user = user;
    this.userID = userID;
    this.group = group;
    this.groupID = groupID;
    this.state = state;
    this.processID = processID;
    this.parentProcessID = parentProcessID;
    this.threadCount = threadCount;
    this.priority = priority;
    this.virtualSize = virtualSize;
    this.residentSetSize = residentSetSize;
    this.memoryPercent = memoryPercent;
    this.kernelTime = kernelTime;
    this.userTime = userTime;
    this.upTime = upTime;
    this.cpuPercent = cpuPercent;
    this.startTime = startTime;
    this.bytesRead = bytesRead;
    this.bytesWritten = bytesWritten;
}
 

import oshi.software.os.OSProcess; //导入依赖的package包/类
public OSProcess.State getState() {
    return state;
}