{"id":688,"date":"2026-06-13T23:27:05","date_gmt":"2026-06-13T22:27:05","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=688"},"modified":"2026-07-07T23:28:15","modified_gmt":"2026-07-07T22:28:15","slug":"die-vector-api-in-java-25-simd-beschleunigung-fuer-numerische-berechnungen","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=688","title":{"rendered":"Die Vector API in Java 25 \u2013 SIMD-Beschleunigung f\u00fcr numerische Berechnungen"},"content":{"rendered":"\n

Die Anforderung an moderne Java-Anwendungen w\u00e4chst stetig: Ob Machine Learning, Bildverarbeitung oder wissenschaftliche Simulationen \u2014 immer h\u00e4ufiger m\u00fcssen gro\u00dfe Datenmengen in k\u00fcrzester Zeit verarbeitet werden. W\u00e4hrend Java-Entwickler traditionell auf native Bibliotheken oder JNI zur\u00fcckgreifen mussten, um SIMD-Instruktionen (Single Instruction, Multiple Data) der CPU zu nutzen, bietet die Vector API seit Java 16 eine plattformunabh\u00e4ngige L\u00f6sung direkt im JDK.<\/p>\n\n\n\n

Dieser Artikel zeigt, wie du mit der Vector API numerische Berechnungen auf das n\u00e4chste Leistungsniveau hebst \u2014 ohne eine Zeile C-Code oder JNI.<\/p>\n\n\n\n

Was ist die Vector API?<\/h2>\n\n\n\n

Die Vector API (JEP 508 im 10. Inkubator in Java 25) erlaubt es, Vektoroperationen direkt in Java zu schreiben. Der JIT-Compiler (C2) \u00fcbersetzt diese plattformspezifisch in AVX2- (x86-64), AVX-512- (x86-64) oder NEON-Instruktionen (AArch64). Anders als die Auto-Vektorisierung des Compilers, die oft scheitert, gibt dir die Vector API deterministisch Kontrolle \u00fcber die SIMD-Nutzung.<\/p>\n\n\n\n

Wichtig: Die API befindet sich noch im Inkubator-Stadium (Modul jdk.incubator.vector<\/code>). Sie wird voraussichtlich gemeinsam mit Project Valhallas Value Classes finalisiert.<\/p>\n\n\n\n

Hello World der Vector API: Vektoraddition<\/h2>\n\n\n\n

Das einfachste Beispiel sind zwei int<\/code>-Arrays, die elementweise addiert werden:<\/p>\n\n\n

import jdk.incubator.vector.IntVector;\nimport jdk.incubator.vector.VectorSpecies;\n\npublic<\/span> class<\/span> VectorAdd<\/span> <\/span>{\n    static<\/span> final<\/span> VectorSpecies<Integer> SPECIES = IntVector.SPECIES_PREFERRED;\n\n    public<\/span> static<\/span> int[] add(int[] a, int[] b) {\n        int[] result = new<\/span> int[a.length];\n        int i = 0<\/span>;\n        int bound = SPECIES.loopBound(a.length);\n\n        for<\/span> (; i < bound; i += SPECIES.length()) {\n            var<\/span> va = IntVector.fromArray(SPECIES, a, i);\n            var<\/span> vb = IntVector.fromArray(SPECIES, b, i);\n            va.add(vb).intoArray(result, i);\n        }\n        for<\/span> (; i < a.length; i++) {\n            result[i] = a[i] + b[i];\n        }\n        return<\/span> result;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Die Klasse IntVector<\/code> l\u00e4dt eine feste Anzahl von int<\/code>-Werten (z.B. 8 auf AVX2, 16 auf AVX-512) in ein Vektorregister, addiert sie in einer einzigen CPU-Instruktion und schreibt das Ergebnis zur\u00fcck. Der VectorSpecies<Integer><\/code> definiert dabei Elementtyp und Vektorbreite. SPECIES_PREFERRED<\/code> w\u00e4hlt automatisch die optimale Breite f\u00fcr die aktuelle Plattform.<\/p>\n\n\n\n
Der Rest des Schleifenk\u00f6rpers (i < a.length<\/code>) behandelt die \u00fcbrig gebliebenen Elemente, die nicht in einen vollen Vektor passen \u2014 der sogenannte \u201eScalar Tail“.<\/p>\n\n\n\n
Skalarprodukt mit Reduce-Lanes<\/h2>\n\n\n\n
Etwas spannender wird es beim Skalarprodukt, bei dem das Ergebnis aller Einzelprodukte auf einen Wert reduziert wird:<\/p>\n\n\n
import<\/span> jdk.incubator.vector.FloatVector;\nimport<\/span> jdk.incubator.vector.VectorOperators;\n\nstatic<\/span> final VectorSpecies<Float> FSPECIES = FloatVector.SPECIES_PREFERRED;\n\npublic static<\/span> float dotProduct(float[] a, float[] b) {\n    float sum = 0.0<\/span>f;\n    int i = 0<\/span>;\n    int bound = FSPECIES.loopBound(a.length);\n\n    for<\/span> (; i < bound; i += FSPECIES.length()) {\n        var<\/span> va = FloatVector.fromArray(FSPECIES, a, i);\n        var<\/span> vb = FloatVector.fromArray(FSPECIES, b, i);\n        sum += va.mul(vb).reduceLanes(VectorOperators.ADD);\n    }\n    for<\/span> (; i < a.length; i++) {\n        sum += a[i] * b[i];\n    }\n    return<\/span> sum;\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
mul(vb)<\/code> multipliziert die Elemente beider Vektoren (lane-wise), und reduceLanes(ADD)<\/code> summiert das Ergebnisvektor-Register in einen einzelnen float<\/code>-Wert. Diese Kombination mappt ideal auf moderne FMA-Instruktionen (Fused Multiply-Add).<\/p>\n\n\n\n
Matrix-Multiplikation<\/h2>\n\n\n\n
Die wahre St\u00e4rke entfaltet die API bei mehrdimensionalen Operationen. Diese Matrix-Multiplikation nutzt fma()<\/code> (Fused Multiply-Add) f\u00fcr optimale Genauigkeit und Performance:<\/p>\n\n\n
import jdk.incubator.vector.DoubleVector;\n\nstatic<\/span> final<\/span> VectorSpecies<Double> DSPECIES = DoubleVector.SPECIES_PREFERRED;\n\npublic<\/span> static<\/span> double[][] matmul(double[][] A, double[][] B) {\n    int m = A.length, n = B[0<\/span>].length, inner = B.length;\n    double[][] C = new<\/span> double[m][n];\n\n    for<\/span> (int i = 0<\/span>; i < m; i++) {\n        for<\/span> (int k = 0<\/span>; k < inner; k++) {\n            double aik = A[i][k];\n            int j = 0<\/span>;\n            int bound = DSPECIES.loopBound(n);\n            for<\/span> (; j < bound; j += DSPECIES.length()) {\n                var<\/span> vb = DoubleVector.fromArray(DSPECIES, B[k], j);\n                var<\/span> vc = DoubleVector.fromArray(DSPECIES, C[i], j);\n                vb.fma(aik, vc).intoArray(C[i], j);\n            }\n            for<\/span> (; j < n; j++) {\n                C[i][j] += aik * B[k][j];\n            }\n        }\n    }\n    return<\/span> C;\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Die Methode fma(scale, addend)<\/code> berechnet vb * aik + vc<\/code> in einer einzigen Hardware-Instruktion \u2014 doppelt so schnell wie getrenntes Mul+Add.<\/p>\n\n\n\n
Transzendente Funktionen<\/h2>\n\n\n\n
Die FloatVector<\/code>– und DoubleVector<\/code>-Klassen bieten auch vektorisierte Varianten von sin()<\/code>, cos()<\/code>, exp()<\/code>, log()<\/code>, sqrt()<\/code> und vielen weiteren \u2014 unterst\u00fctzt auf x64 (Linux\/Windows) durch Intels SVML, auf ARM und RISC-V (Linux\/macOS) durch SLEEF:<\/p>\n\n\n
public static<\/span> float[] vectorExp(float[] arr) {\n    float[] result = new<\/span> float[arr.length];\n    int i = 0<\/span>, bound = FSPECIES.loopBound(arr.length);\n    for<\/span> (; i < bound; i += FSPECIES.length()) {\n        FloatVector.fromArray(FSPECIES, arr, i)\n                   .exp()\n                   .intoArray(result, i);\n    }\n    for<\/span> (; i < arr.length; i++) result[i] = (float) Math<\/span>.exp(arr[i]);\n    return<\/span> result;\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Build-Setup (Maven & Gradle)<\/h2>\n\n\n\n
Da die Vector API ein Inkubator-Modul ist, musst du sie explizit aktivieren:<\/p>\n\n\n\n
Maven:<\/strong><\/p>\n\n\n
<plugin<\/span>><\/span>\n    <groupId<\/span>><\/span>org.apache.maven.plugins<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>maven-compiler-plugin<\/artifactId<\/span>><\/span>\n    <configuration<\/span>><\/span>\n        <compilerArgs<\/span>><\/span>\n            <arg<\/span>><\/span>--add-modules<\/arg<\/span>><\/span>\n            <arg<\/span>><\/span>jdk.incubator.vector<\/arg<\/span>><\/span>\n        <\/compilerArgs<\/span>><\/span>\n    <\/configuration<\/span>><\/span>\n<\/plugin<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Gradle:<\/strong><\/p>\n\n\n
tasks.withType(JavaCompile) {\n    options.compilerArgs += ['--add-modules'<\/span>, 'jdk.incubator.vector'<\/span>]\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Kommandozeile:<\/strong><\/p>\n\n\n
javac<\/span> --add-modules<\/span> jdk<\/span>.incubator<\/span>.vector<\/span> MeinProgramm<\/span>.java<\/span>\njava<\/span> --add-modules<\/span> jdk<\/span>.incubator<\/span>.vector<\/span> MeinProgramm<\/span>\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Performance-Einordnung<\/h2>\n\n\n\n
Die Vector API lohnt sich besonders bei gro\u00dfen Arrays mit vielen Iterationen. In eigenen Benchmarks erreicht die vektorisierte Vektoraddition auf einem Intel Core i7 mit AVX2 etwa das 3- bis 4-fache der skalaren Variante. Die Gewinne steigen mit AVX-512 nochmals signifikant.<\/p>\n\n\n\n
Entscheidend ist, dass der VectorSpecies<\/code> als static final<\/code> Feld deklariert wird \u2014 nur dann kann C2 ihn als Konstante betrachten und optimale Instruktionen generieren. Ebenfalls wichtig: C2-Only. Die Vector API wird nur von der h\u00f6chsten JIT-Stufe intrinsifiziert.<\/p>\n\n\n\n
Fazit<\/h2>\n\n\n\n
Die Vector API bringt SIMD-Performance in idiomatisches Java \u2014 ohne native Abh\u00e4ngigkeiten, JNI oder plattformspezifischen Code. Sie eignet sich f\u00fcr alle rechenintensiven Anwendungen von Bildverarbeitung bis zu ML-Inferenz. Die Inkubator-Phase sollte kein Hindernis sein: In Java 25 ist es bereits der 10. Inkubator, die API ist stabil und produktionsreif.<\/p>\n\n\n\n
F\u00fcr alle, die numerisch anspruchsvolle Java-Anwendungen schreiben: Gebt der Vector API eine Chance \u2014 eure CPU wird es euch danken.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die Anforderung an moderne Java-Anwendungen w\u00e4chst stetig: Ob Machine Learning, Bildverarbeitung oder wissenschaftliche Simulationen \u2014 immer h\u00e4ufiger m\u00fcssen gro\u00dfe Datenmengen in k\u00fcrzester Zeit verarbeitet werden. W\u00e4hrend Java-Entwickler traditionell auf native Bibliotheken oder JNI zur\u00fcckgreifen mussten, um SIMD-Instruktionen (Single Instruction, Multiple Data) der CPU zu nutzen, bietet die Vector API seit Java 16 eine plattformunabh\u00e4ngige L\u00f6sung […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-688","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/688","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=688"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/688\/revisions"}],"predecessor-version":[{"id":689,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/688\/revisions\/689"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=688"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=688"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=688"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}