For eksempel, tenk deg at programmet ditt har en hovedtråd som er ansvarlig for å vise brukergrensesnittet. Samtidig kan du opprette en ekstra tråd for å laste inn data fra nettverket eller utføre komplekse beregninger. Dette bidrar til å gjøre programmet mer responsivt og effektivt.

Deklarering av en tråd i Java

Med Thread-klassen kan du opprette en underklasse av Thread-klassen og overstyre run() -metoden, som inneholder koden som skal kjøres i den nye tråden.

Main.java


              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();

Bruk av Runnable-grensesnittet

Med Runnable -grensesnittet kan du implementere Runnable-grensesnittet, definere en run()-metode, og sende det til konstruktøren til Thread-klassen.

Main.java


              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();

Arv av Thread-klassen

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

Main.java


              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 av Runnable-grensesnittet

Du kan også implementere Runnable-grensesnittet og i det implementere run()-metoden:

Main.java


              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
    }
}

Merk

Metoden run() i en Java-tråd gjør det mulig å utføre kode i en separat tråd, inkludert oppgaver som databehandling, beregninger, nedlasting av filer og sending eller mottak av data over nettverket.

Forskjell mellom Thread og Runnable

I Java er en Thread en spesiell kanal som muliggjør samtidig utførelse av oppgaver, slik at programmet kan utføre operasjoner i en separat tråd, for eksempel beregninger eller langvarige prosesser som lasting av data.

Runnable-grensesnittet, med sin enkeltstående run()-metode, definerer en oppgave som skal utføres av en tråd. Du kan sende en Runnable-implementasjon til en Thread-konstruktør for å kjøre oppgaven i en ny tråd. Denne metoden bidrar til effektiv håndtering og utførelse av parallelle oppgaver.

Metoder tilgjengelig for tråder i Java

Start en tråd ved å bruke start()-metoden, som angir at koden skal kjøres i en ny tråd. Dette betyr at hoved-tråden fortsetter å utføre sin egen kode og venter ikke på at den nylig startede tråden skal fullføres.

Main.java


              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 for at hovedtråden kan vente på utførelsen av tråden den startet ved å bruke join()-metoden. Denne metoden venter til tråden er fullstendig utført. Du kan sjekke om tråden kjører for øyeblikket ved å bruke 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 eksempelet, før join() kalles, arbeidet tråden. Etter at join() er kalt, gjør den det ikke, fordi join() betyr at vi vil vente på dette punktet til tråden har fullført sin utførelse.

Hvis vi ønsker å stoppe en tråd, kan vi bruke interrupt()-metoden. For at dette skal fungere, må vi imidlertid sjekke om tråden vi stopper er avbrutt.

Main.java


              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 eksempelet oppretter en tråd som kjører en oppgave i en løkke til den blir avbrutt. Når tråden blir avbrutt mens den sover, kastes et unntak, håndteres ved å sette avbruddsflagget, og deretter avsluttes tråden.

Uten en InterruptedException-unntakshåndterer i tråden, ville tråden ikke blitt avbrutt.

Merk

Disse metodene lar deg administrere livssyklus og utførelse av tråder i Java, og gir fleksibilitet og kontroll over flertrådede applikasjoner. I de følgende kapitlene vil vi utforske mer om disse metodene.

1. Hva er en tråd i Java?

2. Hva er forskjellen mellom Thread-klassen og Runnable-grensesnittet i Java?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 3

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Awesome!

Completion rate improved to 3.33

Sveip for å vise menyen

Deklarering av en tråd i Java

Med Thread-klassen kan du opprette en underklasse av Thread-klassen og overstyre run() -metoden, som inneholder koden som skal kjøres i den nye tråden.

Main.java


              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();

Bruk av Runnable-grensesnittet

Med Runnable -grensesnittet kan du implementere Runnable-grensesnittet, definere en run()-metode, og sende det til konstruktøren til Thread-klassen.

Main.java


              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();

Arv av Thread-klassen

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

Main.java


              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 av Runnable-grensesnittet

Du kan også implementere Runnable-grensesnittet og i det implementere run()-metoden:

Main.java


              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
    }
}

Merk

Forskjell mellom Thread og Runnable

Metoder tilgjengelig for tråder i Java

Main.java


              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());
    }
}

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
}

Hvis vi ønsker å stoppe en tråd, kan vi bruke interrupt()-metoden. For at dette skal fungere, må vi imidlertid sjekke om tråden vi stopper er avbrutt.

Main.java


              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();
    }
}

Uten en InterruptedException-unntakshåndterer i tråden, ville tråden ikke blitt avbrutt.

Merk

1. Hva er en tråd i Java?

2. Hva er forskjellen mellom Thread-klassen og Runnable-grensesnittet i Java?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 3

Tråder i Java

Deklarering av en tråd i Java

Bruk av Runnable-grensesnittet

Arv av Thread-klassen

Implementering av Runnable-grensesnittet

Forskjell mellom Thread og Runnable

Metoder tilgjengelig for tråder i Java

1. Hva er en tråd i Java?

2. Hva er forskjellen mellom Thread-klassen og Runnable-grensesnittet i Java?

Awesome!

Tråder i Java

Deklarering av en tråd i Java

Bruk av Runnable-grensesnittet

Arv av Thread-klassen

Implementering av Runnable-grensesnittet

Forskjell mellom Thread og Runnable

Metoder tilgjengelig for tråder i Java

1. Hva er en tråd i Java?

2. Hva er forskjellen mellom Thread-klassen og Runnable-grensesnittet i Java?