Maximum en parallèle

Chaque fil écrit dans sa case du tableau maxTranche : aucune case n'est partagée en écriture, donc pas de verrou. Le join garantit en outre que le fil principal voit les valeurs écrites par les fils terminés.

static int maximum(int[] t, int k) throws InterruptedException {
    int[] maxTranche = new int[k];                 // chaque fil écrit dans SA case
    Thread[] fils = new Thread[k];
    for (int j = 0; j < k; j++) {
        int de = j * t.length / k, a = (j + 1) * t.length / k;   // tranche [de, a)
        int numero = j;
        fils[j] = new Thread(() -> {
            int m = Integer.MIN_VALUE;
            for (int i = de; i < a; i++) m = Math.max(m, t[i]);
            maxTranche[numero] = m;
        });
        fils[j].start();
    }
    for (Thread f : fils) f.join();                // après join, maxTranche est complet
    int m = Integer.MIN_VALUE;
    for (int x : maxTranche) m = Math.max(m, x);
    return m;
}

Sur un tableau de dix millions d'entiers aléatoires (graine $42$), comparé au maximum calculé par une boucle simple :

k = 1 : 999999672  (correct)
k = 2 : 999999672  (correct)
k = 3 : 999999672  (correct)
k = 4 : 999999672  (correct)
k = 7 : 999999672  (correct)

Les bornes $jn/k$ et $(j+1)n/k$ découpent exactement $[0,n)$, même quand $k$ ne divise pas $n$ : la tranche $j$ s'arrête là où commence la tranche $j+1$. Attention, j * t.length pourrait dépasser la capacité d'un int pour un très grand tableau.