Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Lære Tråde i Java | Grundlæggende om Multithreading
Multitrådning i Java

bookTråde i Java

For eksempel, forestil dig at dit program har en hovedtråd ansvarlig for at vise brugergrænsefladen. Samtidig kan du oprette en ekstra tråd til at indlæse data fra netværket eller udføre komplekse beregninger. Dette hjælper med at gøre programmet mere responsivt og effektivt.

Deklaration af en tråd i Java

Med Thread: klassen kan du oprette en underklasse af Thread-klassen og overskrive run() -metoden, som indeholder den kode, der vil blive udført i den nye tråd.

Main.java

Main.java

copy

              
123456789

            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Brug af Runnable-interfacet

Med Runnable interfacet kan du implementere Runnable-interfacet, definere en run()-metode og videregive den til Thread-klassens konstruktør.

Main.java

Main.java

copy

              
123456789101112

            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Thread-klassearv

Alternativt kan du arve Thread-klassen og overskrive run()-metoden.

Main.java

Main.java

copy

              
123456789

            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implementering af Runnable-interfacet

Det er også muligt at implementere Runnable-interfacet og i det implementere run()-metoden:

Main.java

Main.java

copy

              
123456789

            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}
Note
Bemærk

Metoden run() i en Java tråd muliggør udførelse af kode i en separat tråd, herunder opgaver som databehandling, beregninger, download af filer samt afsendelse eller modtagelse af data over netværket.

Forskel mellem Thread og Runnable

I Java er en Thread en særlig kanal, der muliggør samtidig udførelse af opgaver, så programmet kan udføre operationer i en separat tråd, såsom beregninger eller langvarige processer som dataloading.

Runnable-interfacet med sin enkeltstående run()-metode definerer en opgave, der skal udføres af en tråd. Du kan videregive en Runnable-implementering til en Thread-konstruktør for at køre opgaven i en ny tråd. Denne metode hjælper med effektiv håndtering og udførelse af parallelle opgaver.

Metoder tilgængelige for tråde i Java

Start af en tråd ved hjælp af start()-metoden, hvilket angiver, at koden skal køre i en ny tråd. Dette betyder, at hovedtråden fortsætter med at udføre sin egen kode og ikke venter på, at den nystartede tråd afsluttes.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Vi har også en metode, hvor hovedtråden kan vente på udførelsen af den tråd, den har startet, ved at bruge join()-metoden. Denne metode venter, indtil tråden er fuldt udført. Du kan kontrollere, om tråden kører i øjeblikket, ved at bruge isAlive()-metoden.

Koden Thread.sleep(5000) pauser tråden i 5000 millisekunder (5 sekunder).

try {
    Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
} catch (InterruptedException e) {
    throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
}

I eksemplet arbejdede tråden, før join() blev kaldt. Efter at have kaldt join() gør den det ikke, fordi join() betyder, at vi vil vente på dette punkt, indtil tråden afslutter sin udførelse.

Hvis vi ønsker at stoppe en tråd, kan vi bruge interrupt()-metoden. For at det skal virke, skal vi dog kontrollere, om den tråd, vi stopper, er blevet afbrudt.

Main.java

Main.java

copy

              
123456789101112131415161718192021222324252627282930313233

            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Dette eksempel opretter en tråd, der kører en opgave i en løkke, indtil den bliver afbrudt. Når tråden afbrydes, mens den sover, kastes en undtagelse, som håndteres ved at sætte afbrudsflaget, hvorefter tråden afsluttes.

Uden en InterruptedException-undtagelseshåndtering i tråden ville tråden ikke blive afbrudt.

Note
Bemærk

Disse metoder giver dig mulighed for at styre livscyklus og udførelse af tråde i Java, hvilket giver fleksibilitet og kontrol over multitrådede applikationer. I de følgende kapitler vil vi udforske mere om disse metoder.

1. Hvad er en tråd i Java?

2. Hvad er forskellen mellem Thread-klassen og Runnable-interfacet i Java?

question mark

Hvad er en tråd i Java?

Select the correct answer

question mark

Hvad er forskellen mellem Thread-klassen og Runnable-interfacet i Java?

Select the correct answer

Var alt klart?

Hvordan kan vi forbedre det?

Tak for dine kommentarer!

Sektion 1. Kapitel 3

Spørg AI

expand

Spørg AI

ChatGPT

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Suggested prompts:

Can you explain the difference between extending the Thread class and implementing the Runnable interface?

How does the start() method work in Java threads?

What happens if I call the run() method directly instead of start()?

Awesome!

Completion rate improved to 3.33

bookTråde i Java

Stryg for at vise menuen

For eksempel, forestil dig at dit program har en hovedtråd ansvarlig for at vise brugergrænsefladen. Samtidig kan du oprette en ekstra tråd til at indlæse data fra netværket eller udføre komplekse beregninger. Dette hjælper med at gøre programmet mere responsivt og effektivt.

Deklaration af en tråd i Java

Med Thread: klassen kan du oprette en underklasse af Thread-klassen og overskrive run() -metoden, som indeholder den kode, der vil blive udført i den nye tråd.

Main.java

Main.java

copy

              
123456789

            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Brug af Runnable-interfacet

Med Runnable interfacet kan du implementere Runnable-interfacet, definere en run()-metode og videregive den til Thread-klassens konstruktør.

Main.java

Main.java

copy

              
123456789101112

            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Thread-klassearv

Alternativt kan du arve Thread-klassen og overskrive run()-metoden.

Main.java

Main.java

copy

              
123456789

            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implementering af Runnable-interfacet

Det er også muligt at implementere Runnable-interfacet og i det implementere run()-metoden:

Main.java

Main.java

copy

              
123456789

            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}
Note
Bemærk

Metoden run() i en Java tråd muliggør udførelse af kode i en separat tråd, herunder opgaver som databehandling, beregninger, download af filer samt afsendelse eller modtagelse af data over netværket.

Forskel mellem Thread og Runnable

I Java er en Thread en særlig kanal, der muliggør samtidig udførelse af opgaver, så programmet kan udføre operationer i en separat tråd, såsom beregninger eller langvarige processer som dataloading.

Runnable-interfacet med sin enkeltstående run()-metode definerer en opgave, der skal udføres af en tråd. Du kan videregive en Runnable-implementering til en Thread-konstruktør for at køre opgaven i en ny tråd. Denne metode hjælper med effektiv håndtering og udførelse af parallelle opgaver.

Metoder tilgængelige for tråde i Java

Start af en tråd ved hjælp af start()-metoden, hvilket angiver, at koden skal køre i en ny tråd. Dette betyder, at hovedtråden fortsætter med at udføre sin egen kode og ikke venter på, at den nystartede tråd afsluttes.

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526

            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Vi har også en metode, hvor hovedtråden kan vente på udførelsen af den tråd, den har startet, ved at bruge join()-metoden. Denne metode venter, indtil tråden er fuldt udført. Du kan kontrollere, om tråden kører i øjeblikket, ved at bruge isAlive()-metoden.

Koden Thread.sleep(5000) pauser tråden i 5000 millisekunder (5 sekunder).

try {
    Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
} catch (InterruptedException e) {
    throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
}

I eksemplet arbejdede tråden, før join() blev kaldt. Efter at have kaldt join() gør den det ikke, fordi join() betyder, at vi vil vente på dette punkt, indtil tråden afslutter sin udførelse.

Hvis vi ønsker at stoppe en tråd, kan vi bruge interrupt()-metoden. For at det skal virke, skal vi dog kontrollere, om den tråd, vi stopper, er blevet afbrudt.

Main.java

Main.java

copy

              
123456789101112131415161718192021222324252627282930313233

            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Dette eksempel opretter en tråd, der kører en opgave i en løkke, indtil den bliver afbrudt. Når tråden afbrydes, mens den sover, kastes en undtagelse, som håndteres ved at sætte afbrudsflaget, hvorefter tråden afsluttes.

Uden en InterruptedException-undtagelseshåndtering i tråden ville tråden ikke blive afbrudt.

Note
Bemærk

Disse metoder giver dig mulighed for at styre livscyklus og udførelse af tråde i Java, hvilket giver fleksibilitet og kontrol over multitrådede applikationer. I de følgende kapitler vil vi udforske mere om disse metoder.

1. Hvad er en tråd i Java?

2. Hvad er forskellen mellem Thread-klassen og Runnable-interfacet i Java?

question mark

Hvad er en tråd i Java?

Select the correct answer

question mark

Hvad er forskellen mellem Thread-klassen og Runnable-interfacet i Java?

Select the correct answer

Var alt klart?

Hvordan kan vi forbedre det?

Tak for dine kommentarer!

Sektion 1. Kapitel 3
some-alt