Come posso sapere se sono in esecuzione in JVM a 64 bit o JVM a 32 bit (all'interno di un programma)?

Per alcune versioni di Java, è possibile controllare la bitness della JVM dalla riga di comando con i flag -d32 e -d64.

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

Per verificare la presenza di una JVM a 64 bit, eseguire:

$ java -d64 -version

Se non è una JVM a 64 bit, otterrai questo:

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

Allo stesso modo, per verificare la presenza di una JVM a 32 bit, eseguire:

$ java -d32 -version

Se non è una JVM a 32 bit, otterrai questo:

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

Questi flag sono stati aggiunti in Java 7, deprecato in Java 9, rimosso in Java 10, e non più disponibile su versioni moderne di Java.

Basta digitare java -version nella console.

Se è in esecuzione una versione a 64 bit, verrà visualizzato un messaggio del tipo:

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)

Una versione a 32 bit mostrerà qualcosa di simile a:

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)

Nota Client invece di 64-Bit Server nella terza riga. La parte Client/Server è irrilevante, è l'assenza di 64-Bit che conta.

Se sul sistema sono installate più versioni Java, passare alla cartella /bin della versione Java che si desidera controllare e digitare java -version lì.

Ho installato JVM a 32 bit e l'ho riprovato di nuovo, sembra che quanto segue ti dica bitness JVM, non OS arch:

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

Questo è stato testato sia contro SUN e IBM JVM (32 e 64-bit). Chiaramente, la proprietà di sistema non è solo l'arco del sistema operativo.

Informazioni complementari:

Su un processo in esecuzione è possibile utilizzare (almeno con alcune versioni recenti di 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

Dove 14680 è il PID della jvm che esegue l'applicazione. "operativo.arch " funziona anche.

Sono supportati anche altri scenari:

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

Tuttavia considera anche questa nota:

"NOTA - Questa utility non è supportata e potrebbe essere disponibile o meno nelle versioni future di JDK. Nei sistemi Windows dove dbgent.dll non presente, 'Strumenti di debug per Windows' deve essere installato per avere questi strumenti di lavoro. Anche la variabile di ambiente PATH dovrebbe contenere la posizione di jvm.dll utilizzato dal processo di destinazione o la posizione da cui è stato prodotto il file di Crash Dump."

Su Linux, è possibile ottenere informazioni sull'intestazione ELF utilizzando uno dei seguenti due comandi:

file {YOUR_JRE_LOCATION_HERE}/bin/java

O / p: ELF eseguibile LSB a 64 bit , AMD x86-64, versione 1 (SYSV), per GNU / Linux 2.4.0, collegato dinamicamente (utilizza librerie condivise), per GNU/Linux 2.4.0, non stripped

O

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

O / p: Classe: ELF64

Se si utilizza JNA, è possibile verificare se com.sun.jna.Native.POINTER_SIZE == 4 (32 bit) o com.sun.jna.Native.POINTER_SIZE == 8 (64 bit).

Se stai usando JNA, puoi farloPlatform.is64Bit().

Sotto Windows 7 nella sezione "Pannello di Controllo" sotto "programmi | Programmi e Funzionalità" 64-bit varianti di JRE & JDK sono elencati con "64-bit" tra parentesi (ad esempio "Java SE Development Kit 7 Aggiornamento 65 (64-Bit)"), mentre per la versione a 32 bit di varianti variante non è citato nelle parentesi (ad es. "Java SE Development Kit 8 di Aggiornamento 60").

Questo è il modo in cui JNA risolve questo con 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;
        }
}

Per Windows, è possibile controllare la posizione di Java home. Se contiene (x86) è 32-bit altrimenti 64-bit:

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

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

Percorsi di esempio:

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

Perché preoccuparsi di una soluzione unica Windows?

Se hai bisogno di sapere su quale versione bit stai eseguendo, probabilmente stai giocando con il codice nativo su Windows, quindi l'indipendenza dalla piattaforma è comunque fuori dalla finestra.

Per ottenere la versione di JVM attualmente in esecuzione il programma

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