Ermittlung der Anzahl der Kerne in Java

Question

Wie kann ich die Anzahl der für meine Anwendung verfügbaren Kerne im Java-Code ermitteln?

Answer 1

int cores = Runtime.getRuntime().availableProcessors();

Wenn cores kleiner als eins ist, stirbt entweder Ihr Prozessor, Ihre JVM hat einen schwerwiegenden Fehler, oder das Universum explodiert.

Answer 2

Wenn Sie die Anzahl der physischen Kerne abfragen möchten, können Sie cmd und den Terminal-Befehl ausführen und dann die Ausgabe analysieren, um die benötigten Informationen zu erhalten.unten wird eine Funktion gezeigt, die die Anzahl der physischen Kerne zurückgibt.

private int getNumberOfCPUCores() {
    OSValidator osValidator = new OSValidator();
    String command = "";
    if(osValidator.isMac()){
        command = "sysctl -n machdep.cpu.core_count";
    }else if(osValidator.isUnix()){
        command = "lscpu";
    }else if(osValidator.isWindows()){
        command = "cmd /C WMIC CPU Get /Format:List";
    }
    Process process = null;
    int numberOfCores = 0;
    int sockets = 0;
    try {
        if(osValidator.isMac()){
            String[] cmd = { "/bin/sh", "-c", command};
            process = Runtime.getRuntime().exec(cmd);
        }else{
            process = Runtime.getRuntime().exec(command);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    BufferedReader reader = new BufferedReader(
            new InputStreamReader(process.getInputStream()));
    String line;

    try {
        while ((line = reader.readLine()) != null) {
            if(osValidator.isMac()){
                numberOfCores = line.length() > 0 ? Integer.parseInt(line) : 0;
            }else if (osValidator.isUnix()) {
                if (line.contains("Core(s) per socket:")) {
                    numberOfCores = Integer.parseInt(line.split("\\s+")[line.split("\\s+").length - 1]);
                }
                if(line.contains("Socket(s):")){
                    sockets = Integer.parseInt(line.split("\\s+")[line.split("\\s+").length - 1]);
                }
            } else if (osValidator.isWindows()) {
                if (line.contains("NumberOfCores")) {
                    numberOfCores = Integer.parseInt(line.split("=")[1]);
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    if(osValidator.isUnix()){
        return numberOfCores * sockets;
    }
    return numberOfCores;
}

OSValidator-Klasse:

public class OSValidator {

private static String OS = System.getProperty("os.name").toLowerCase();

public static void main(String[] args) {

    System.out.println(OS);

    if (isWindows()) {
        System.out.println("This is Windows");
    } else if (isMac()) {
        System.out.println("This is Mac");
    } else if (isUnix()) {
        System.out.println("This is Unix or Linux");
    } else if (isSolaris()) {
        System.out.println("This is Solaris");
    } else {
        System.out.println("Your OS is not support!!");
    }
}

public static boolean isWindows() {
    return (OS.indexOf("win") >= 0);
}

public static boolean isMac() {
    return (OS.indexOf("mac") >= 0);
}

public static boolean isUnix() {
    return (OS.indexOf("nix") >= 0 || OS.indexOf("nux") >= 0 || OS.indexOf("aix") > 0 );
}

public static boolean isSolaris() {
    return (OS.indexOf("sunos") >= 0);
}
public static String getOS(){
    if (isWindows()) {
        return "win";
    } else if (isMac()) {
        return "osx";
    } else if (isUnix()) {
        return "uni";
    } else if (isSolaris()) {
        return "sol";
    } else {
        return "err";
    }
}

}

Answer 3

Dies ist eine weitere Möglichkeit, die Anzahl der CPU-Kerne (und viele andere Informationen) zu ermitteln, aber dieser Code erfordert eine zusätzliche Abhängigkeit:

Informationen zum nativen Betriebssystem und zur Hardware https://github.com/oshi/oshi

SystemInfo systemInfo = new SystemInfo();
HardwareAbstractionLayer hardwareAbstractionLayer = systemInfo.getHardware();
CentralProcessor centralProcessor = hardwareAbstractionLayer.getProcessor();

Ermittelt die Anzahl der für die Verarbeitung verfügbaren logischen CPUs:

centralProcessor.getLogicalProcessorCount();

Answer 4

Wenn Sie die Anzahl der Kerne, die Sie auf Ihrem Rechner haben, mit der Anzahl der Kerne, die Ihnen Ihr Java-Programm liefert, abgleichen möchten, können Sie dies tun.

Im Linux-Terminal: lscpu

Im Windows-Terminal (cmd): echo %NUMBER_OF_PROCESSORS%

Im Mac-Terminal: sysctl -n hw.ncpu

Answer 5

Dies funktioniert unter Windows mit installiertem Cygwin:

System.getenv("NUMBER_OF_PROCESSORS")