Java Academy · Lektion

Skapa parallella strömmar

parallel() och parallelStream().

Lektion 1 av 413 steg

Skapa parallella strömmar är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Så fungerar parallella strömmar

En parallell ström delar upp sina data och bearbetar delarna i flera trådar, som sedan kombinerar resultaten. Målet är högre genomströmning vid stora arbetsmängder.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 1000)
            .parallel()
            .sum();
        System.out.println(sum);
    }
}

parallel() på en befintlig ström

Att anropa parallel() omvandlar en sekventiell ström till en parallell ström. Anropet kan placeras var som helst i pipelinen.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5);
        int total = nums.stream()
            .parallel()
            .mapToInt(Integer::intValue)
            .sum();
        System.out.println(total);
    }
}

parallelStream() på samlingar

Collection.parallelStream() skapar en parallell ström direkt och är en genväg jämfört med stream().parallel().

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "ccc");
        int chars = words.parallelStream()
            .mapToInt(String::length)
            .sum();
        System.out.println(chars);
    }
}

Tillbaka till sekventiell körning

sequential() återställer en ström till körning i en enda tråd. Det senaste anropet av parallel() eller sequential() gäller för hela pipelinen.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 100)
            .parallel()
            .sequential()
            .sum();
        System.out.println(sum);
    }
}

Kontrollera isParallel

isParallel() anger om en ström kommer att köras parallellt.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        System.out.println(IntStream.range(0, 10).isParallel());
        System.out.println(IntStream.range(0, 10).parallel().isParallel());
    }
}

Samma resultat, annan körning

För associativa operationer som summa returnerar parallella och sekventiella strömmar samma resultat. Det är bara körningsstrategin som skiljer sig åt.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int seq = IntStream.rangeClosed(1, 50).sum();
        int par = IntStream.rangeClosed(1, 50).parallel().sum();
        System.out.println(seq == par);
    }
}

Den gemensamma ForkJoinPool

Parallella strömmar använder den delade ForkJoinPool.commonPool(). Standardstorleken är antalet tillgängliga processorer minus ett.

public class Main {
    public static void main(String[] args) {
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

Trådarnas ordning garanteras inte

Med forEach kan parallella strömmar skriva ut i valfri ordning eftersom delarna blir klara vid olika tidpunkter. Använd forEachOrdered om ordningen är viktig.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5)
            .parallel()
            .forEachOrdered(System.out::println);
    }
}

Reduktion kombinerar delresultat

Under huven beräknar en parallell reduktion delresultat för varje del och sammanfogar dem med kombinatorn. Operationen måste vara associativ för att resultatet ska bli korrekt.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int product = IntStream.rangeClosed(1, 6)
            .parallel()
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Samla in parallellt

Ramverket för samlare stöder parallell insamling genom att sammanfoga delbehållare. groupingBy fungerar korrekt parallellt.

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "avocado", "cherry");
        Map<Character, List<String>> byFirst = words.parallelStream()
            .collect(Collectors.groupingBy(w -> w.charAt(0)));
        System.out.println(byFirst);
    }
}

Alla strömmar blir inte snabbare

Det är enkelt att aktivera parallellism, men det är inte alltid fördelaktigt. Små datamängder eller billiga operationer kan vara långsammare parallellt på grund av kostnaden för uppdelning och sammanfogning.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.rangeClosed(1, 10)
            .parallel()
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(count);
    }
}

Snabb kontroll

Vilken trådpool kör parallella strömmar som standard?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du skapade parallella strömmar:

parallel() omvandlar vilken ström som helst; parallelStream() är en genväg för samlingar.
sequential() återställer sekventiell körning; det senaste anropet gäller.
De körs i den delade ForkJoinPool.commonPool().
Resultaten överensstämmer med sekventiell körning för associativa operationer, men ordning och hastighet garanteras inte.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Skapa parallella strömmar” gratis?

Ja – hela texten till ”Skapa parallella strömmar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Skapa parallella strömmar”?

parallel() och parallelStream(). Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Skapa parallella strömmar”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy