Jak mogę sprawdzić, czy działa w 64-bitowym JVM lub 32-bitowym JVM (z poziomu programu)?

Dla niektórych wersji Javy, można sprawdzić bitowość JVM z linii poleceń za pomocą flag -d32 i -d64.

$ java -help
...
    -d32          use a 32-bit data model if available
    -d64          use a 64-bit data model if available

Aby sprawdzić, czy nie ma 64-bitowego JVM, Uruchom:

$ java -d64 -version

Jeśli nie jest to 64-bitowy JVM, dostaniesz to:

Error: This Java instance does not support a 64-bit JVM.
Please install the desired version.

$ java -d32 -version

Jeśli nie jest to 32-bitowy JVM, dostaniesz to:

Error: This Java instance does not support a 32-bit JVM.
Please install the desired version.

Te flagi zostały dodane w Javie 7, przestarzałe w Javie 9, usunięte w Javie 10 i już nie dostępne na nowoczesnych wersjach Javy.

Po prostu wpisz java -version w konsoli.

Jeśli uruchomiona jest wersja 64-bitowa, otrzymasz wiadomość w stylu:

java version "1.6.0_18"
Java(TM) SE Runtime Environment (build 1.6.0_18-b07)
Java HotSpot(TM) 64-Bit Server VM (build 16.0-b13, mixed mode)

Wersja 32 bitowa pokaże coś podobnego do:

java version "1.6.0_41"
Java(TM) SE Runtime Environment (build 1.6.0_41-b02)
Java HotSpot(TM) Client VM (build 20.14-b01, mixed mode, sharing)

Uwaga Client zamiast 64-Bit Server w trzeciej linijce. Część Client/Server jest nieistotna, liczy się brak 64-Bit.

Jeśli w Twoim systemie jest zainstalowanych wiele wersji Java, przejdź do folderu / bin wersji Java, którą chcesz sprawdzić, i wpisz tam java -version.

Zainstalowałem 32-bitowy JVM i powtórzyłem go ponownie, wygląda na to, że poniżej widać bitowość JVM, a nie OS arch:

System.getProperty("os.arch");
#
# on a 64-bit Linux box:
# "x86" when using 32-bit JVM
# "amd64" when using 64-bit JVM

To zostało przetestowane zarówno na SUN i IBM JVM (32 i 64-bit). Oczywiście właściwość systemu to nie tylko łuk systemu operacyjnego.

Informacje uzupełniające:

Na uruchomiony proces możesz użyć (przynajmniej w niektórych ostatnich wersjach Sun JDK5/6):

$ /opt/java1.5/bin/jinfo -sysprops 14680 | grep sun.arch.data.model
Attaching to process ID 14680, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 1.5.0_16-b02
sun.arch.data.model = 32

Gdzie 14680 to PID jvm uruchamiającego aplikację. "os.arch " też działa.

Obsługiwane są również inne scenariusze:

jinfo [ option ] pid
jinfo [ option ] executable core
jinfo [ option ] [server-id@]remote-hostname-or-IP 

Rozważ jednak również tę uwagę:

"Uwaga - to narzędzie nie jest obsługiwane i może być dostępne w przyszłych wersjach JDK. W systemach Windows gdzie dbgent.dll nie jest obecny, "Debugging Tools for Windows" musi być zainstalowany, aby te narzędzia działały. Również zmienna środowiskowa PATH powinna zawierać lokalizację jvm.dll używany przez proces docelowy lub lokalizację, z której powstał plik zrzutu awaryjnego."

W Linuksie można uzyskać informacje o nagłówku ELF, używając jednego z następujących dwóch poleceń:

file {YOUR_JRE_LOCATION_HERE}/bin/java

O / p: ELF 64-bitowy plik wykonywalny LSB , AMD x86-64, Wersja 1 (SYSV), dla GNU/Linux 2.4.0, dynamicznie połączony (używa współdzielonych bibliotek), dla GNU/Linux 2.4.0, nie pozbawiony

Lub

readelf -h {YOUR_JRE_LOCATION_HERE}/bin/java | grep 'Class'

O / p: Klasa: ELF64

Jeśli używasz JNA, możesz sprawdzić, czy com.sun.jna.Native.POINTER_SIZE == 4 (32 bit) czy com.sun.jna.Native.POINTER_SIZE == 8 (64 bit).

Jeśli używasz JNA, możesz to zrobić Platform.is64Bit().

W systemie Windows 7 w panelu sterowania "w sekcji" Programy | Programy i funkcje "64-bitowe warianty JRE i JDK są wymienione jako" 64-bitowe "w nawiasach (np." Java SE Development Kit 7 Update 65 (64-Bit)"), podczas gdy dla 32-bitowych wariantów wariant nie jest wymieniony w w nawiasach (np. po prostu" Java SE Development Kit 8 update 60").

W ten sposób JNA rozwiązuje to z Platform.is64Bit() (https://github.com/java-native-access/jna/blob/master/src/com/sun/jna/Platform.java )

 public static final boolean is64Bit() {
        String model = System.getProperty("sun.arch.data.model",
                                          System.getProperty("com.ibm.vm.bitmode"));
        if (model != null) {
            return "64".equals(model);
        }
        if ("x86-64".equals(ARCH)
            || "ia64".equals(ARCH)
            || "ppc64".equals(ARCH) || "ppc64le".equals(ARCH)
            || "sparcv9".equals(ARCH)
            || "mips64".equals(ARCH) || "mips64el".equals(ARCH)
            || "amd64".equals(ARCH)
            || "aarch64".equals(ARCH)) {
            return true;
        }
        return Native.POINTER_SIZE == 8;
}

ARCH = getCanonicalArchitecture(System.getProperty("os.arch"), osType);

static String getCanonicalArchitecture(String arch, int platform) {
        arch = arch.toLowerCase().trim();
        if ("powerpc".equals(arch)) {
            arch = "ppc";
        }
        else if ("powerpc64".equals(arch)) {
            arch = "ppc64";
        }
        else if ("i386".equals(arch) || "i686".equals(arch)) {
            arch = "x86";
        }
        else if ("x86_64".equals(arch) || "amd64".equals(arch)) {
            arch = "x86-64";
        }
        // Work around OpenJDK mis-reporting os.arch
        // https://bugs.openjdk.java.net/browse/JDK-8073139
        if ("ppc64".equals(arch) && "little".equals(System.getProperty("sun.cpu.endian"))) {
            arch = "ppc64le";
        }
        // Map arm to armel if the binary is running as softfloat build
        if("arm".equals(arch) && platform == Platform.LINUX && isSoftFloat()) {
            arch = "armel";
        }

        return arch;
    }

static {
        String osName = System.getProperty("os.name");
        if (osName.startsWith("Linux")) {
            if ("dalvik".equals(System.getProperty("java.vm.name").toLowerCase())) {
                osType = ANDROID;
                // Native libraries on android must be bundled with the APK
                System.setProperty("jna.nounpack", "true");
            }
            else {
                osType = LINUX;
            }
        }
        else if (osName.startsWith("AIX")) {
            osType = AIX;
        }
        else if (osName.startsWith("Mac") || osName.startsWith("Darwin")) {
            osType = MAC;
        }
        else if (osName.startsWith("Windows CE")) {
            osType = WINDOWSCE;
        }
        else if (osName.startsWith("Windows")) {
            osType = WINDOWS;
        }
        else if (osName.startsWith("Solaris") || osName.startsWith("SunOS")) {
            osType = SOLARIS;
        }
        else if (osName.startsWith("FreeBSD")) {
            osType = FREEBSD;
        }
        else if (osName.startsWith("OpenBSD")) {
            osType = OPENBSD;
        }
        else if (osName.equalsIgnoreCase("gnu")) {
            osType = GNU;
        }
        else if (osName.equalsIgnoreCase("gnu/kfreebsd")) {
            osType = KFREEBSD;
        }
        else if (osName.equalsIgnoreCase("netbsd")) {
            osType = NETBSD;
        }
        else {
            osType = UNSPECIFIED;
        }
}

Dla Windows, możesz sprawdzić lokalizację Java. Jeśli zawiera {[4] } to jest 32-bit inaczej 64-bit:

public static boolean is32Bit()
{
    val javaHome = System.getProperty("java.home");
    return javaHome.contains("(x86)");
}

public static boolean is64Bit()
{
    return !is32Bit();
}

Przykładowe ścieżki:

C:\Program Files (x86)\Java\jdk1.8.0_181\bin\java.exe # 32-bit
C:\Program Files\Java\jdk-10.0.2\bin\java.exe # 64-bit

Po co dbać o Windows jedyne rozwiązanie?

Jeśli chcesz wiedzieć, na której wersji bitowej korzystasz, prawdopodobnie bawisz się natywnym kodem na Windows, więc niezależność platformy i tak jest poza oknem.

Aby pobrać wersję JVM aktualnie uruchamiającą program

System.out.println(Runtime.class.getPackage().getImplementationVersion());