Comment puis-je savoir si je cours dans une JVM 64 bits ou 32 bits (à partir d'un programme)?

Pour certaines versions de Java, vous pouvez vérifier le bit de la JVM à partir de la ligne de commande avec les drapeaux -d32 et -d64.

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

Pour vérifier une JVM 64 bits, exécutez:

$ java -d64 -version

Si ce n'est pas une JVM 64 bits, vous obtiendrez ceci:

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

De même, pour vérifier une JVM 32 bits, exécutez:

$ java -d32 -version

Si ce n'est pas une JVM 32 bits, vous obtiendrez ceci:

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

Ces indicateurs ont été ajoutés dans Java 7, obsolète en Java 9, supprimé en Java 10, et non plus disponible sur les versions modernes de Java.

Tapez simplement java -version dans votre console.

Si une version 64 bits est en cours d'exécution, vous obtiendrez un message comme:

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)

Une version 32 bits montrera quelque chose de similaire à:

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)

Notez Client au lieu de 64-Bit Server dans la troisième ligne. La partie Client/Server n'est pas pertinente, c'est l'absence du 64-Bit qui compte.

Si plusieurs versions Java sont installées sur votre système, accédez au dossier /bin de la version Java que vous souhaitez vérifier et tapez java -version là.

J'ai installé la JVM 32 bits et l'ai réessayé à nouveau, on dirait que ce qui suit vous dit le bitness de la JVM, pas l'arche du système d'exploitation:

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

Cela a été testé contre SUN et IBM JVM (32 et 64 bits). De toute évidence, la propriété system n'est pas seulement l'arche du système d'exploitation.

Informations complémentaires:

Sur un processusen cours d'exécution vous pouvez utiliser (au moins avec certaines versions récentes de 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

Où 14680 est PID de jvm exécutant l'application. "OS.arch" fonctionne aussi.

D'autres scénarios sont également pris en charge:

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

Cependant, considérez également cette note:

"REMARQUE - Cet utilitaire n'est pas pris en charge et peut ou non être disponible dans les futures versions du JDK. Dans les systèmes Windows où dbgent.dll n'est pas présent, "Outils de débogage pour Windows" doit être installé pour que ces outils fonctionnent. La variable d'environnement PATH doit également contenir l'emplacement de la jvm.dll utilisée par le processus cible ou l'emplacement à partir duquel le fichier de vidage sur incident a été produit."

Sous Linux, vous pouvez obtenir des informations d'en-tête ELF en utilisant l'une des deux commandes suivantes:

file {YOUR_JRE_LOCATION_HERE}/bin/java

O/p: ELF exécutable LSB 64 bits , AMD x86-64, version 1 (SYSV), pour GNU/Linux 2.4.0, lié dynamiquement (utilise des bibliothèques partagées), pour GNU/Linux 2.4.0, non dépouillé

Ou

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

O/p: Classe: ELFE64

Si vous utilisez JNA, vous pouvez vérifier si com.sun.jna.Native.POINTER_SIZE == 4 (32 bits) ou com.sun.jna.Native.POINTER_SIZE == 8 (64 bits).

Si vous utilisez JNA, vous pouvez le fairePlatform.is64Bit().

Sous Windows 7 dans le " Panneau de configuration" sous " Programmes | Programmes et fonctionnalités" les variantes 64 bits de JRE & JDK sont listées avec " 64 bits" entre parenthèses (par exemple " Java SE Development Kit 7 Update 65 (64 bits)"), tandis que pour les variantes 32 bits, la variante n'est pas mentionnée entre parenthèses (par exemple, juste " Java SE Development Kit 8 Update 60").

C'est la façon dont JNA résout ce avec 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;
        }
}

Pour Windows, vous pouvez vérifier la Java domicile. Si elle contient (x86) c'est 32-bit sinon 64-bit:

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

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

Exemple de chemins:

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

Pourquoi se soucier d'une Windows seule solution?

Si vous avez besoin de savoir sur quelle version de bit vous utilisez, vous êtes probablement en train de jouer avec le code natif sur Windows, donc l'indépendance de la plate-forme est de toute façon hors de la fenêtre.

Pour obtenir la version de la JVM en cours d'exécution du programme

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