Till exempel, tänk dig att ditt program har en huvudtråd som ansvarar för att visa användargränssnittet. Samtidigt kan du skapa en extra tråd för att ladda data från nätverket eller utföra komplexa beräkningar. Detta bidrar till att göra programmet mer responsivt och effektivt.

Deklarera en tråd i Java

Med Thread: klassen kan du skapa en subklass av Thread-klassen och åsidosätta metoden run() , som innehåller koden som kommer att köras i den nya 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();

Använda Runnable-gränssnittet

Med Runnable -gränssnittet kan du implementera Runnable -gränssnittet, tillhandahålla en run()-metod och skicka det till Thread-klassens konstruktor.

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

Ärva Thread-klassen

Alternativt kan du ärva Thread-klassen och överskrida metoden run().

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-gränssnittet

Det är även möjligt att implementera gränssnittet Runnable och där implementera metoden run():

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

Notering

Metoden run() i en Java-tråd möjliggör exekvering av kod i en separat tråd, inklusive uppgifter som databehandling, beräkningar, nedladdning av filer samt sändning eller mottagning av data över nätverket.

Skillnad mellan Thread och Runnable

I Java är en Thread en speciell kanal som möjliggör samtidig exekvering av uppgifter, vilket gör att programmet kan utföra operationer i en separat tråd, såsom beräkningar eller långvariga processer som datainläsning.

Runnable-gränssnittet, med sin enda run()-metod, definierar en uppgift som ska exekveras av en tråd. Du kan skicka en Runnable-implementering till en Thread-konstruktor för att köra uppgiften i en ny tråd. Denna metod underlättar effektiv hantering och exekvering av parallella uppgifter.

Metoder tillgängliga för trådar i Java

Starta en tråd med hjälp av metoden start(), vilket anger att koden ska köras i en ny tråd. Detta innebär att huvudtråden fortsätter att köra sin egen kod och väntar inte på att den nystartade tråden ska bli klar.

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 också en metod för att låta huvudtråden vänta på att exekveringen av den tråd den startade ska slutföras, genom att använda metoden join(). Denna metod väntar tills tråden är fullständigt exekverad. Du kan kontrollera om tråden för närvarande körs genom att använda metoden isAlive().

Koden Thread.sleep(5000) pausar 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 exemplet, innan join() anropas, arbetade tråden. Efter att join() har anropats gör den inte det, eftersom join() innebär att vi väntar vid den punkten tills tråden har avslutat sin exekvering.

Om vi vill stoppa en tråd kan vi använda metoden interrupt(). För att detta ska fungera måste vi dock kontrollera om tråden vi stoppar är avbruten.

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

Detta exempel skapar en tråd som kör en uppgift i en slinga tills den blir avbruten. När tråden avbryts medan den sover, kastas ett undantag, hanteras genom att avbrottsflaggan sätts, och sedan avslutas tråden.

Utan en undantagshanterare för InterruptedException i tråden skulle tråden inte avbrytas.

Notering

Dessa metoder låter dig hantera livscykel och exekvering av trådar i Java, vilket ger flexibilitet och kontroll över multitrådade applikationer. I följande kapitel kommer vi att utforska mer om dessa metoder.

1. Vad är en tråd i Java?

2. Vad är skillnaden mellan Thread-klassen och Runnable-gränssnittet i Java?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 3

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

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

Svep för att visa menyn

Deklarera en tråd i Java

Med Thread: klassen kan du skapa en subklass av Thread-klassen och åsidosätta metoden run() , som innehåller koden som kommer att köras i den nya 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();

Använda Runnable-gränssnittet

Med Runnable -gränssnittet kan du implementera Runnable -gränssnittet, tillhandahålla en run()-metod och skicka det till Thread-klassens konstruktor.

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

Ärva Thread-klassen

Alternativt kan du ärva Thread-klassen och överskrida metoden run().

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-gränssnittet

Det är även möjligt att implementera gränssnittet Runnable och där implementera metoden run():

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

Notering

Skillnad mellan Thread och Runnable

Metoder tillgängliga för trådar 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) pausar 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
}

Om vi vill stoppa en tråd kan vi använda metoden interrupt(). För att detta ska fungera måste vi dock kontrollera om tråden vi stoppar är avbruten.

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

Utan en undantagshanterare för InterruptedException i tråden skulle tråden inte avbrytas.

Notering

1. Vad är en tråd i Java?

2. Vad är skillnaden mellan Thread-klassen och Runnable-gränssnittet i Java?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 3

Trådar i Java

Deklarera en tråd i Java

Använda Runnable-gränssnittet

Ärva Thread-klassen

Implementering av Runnable-gränssnittet

Skillnad mellan Thread och Runnable

Metoder tillgängliga för trådar i Java

1. Vad är en tråd i Java?

2. Vad är skillnaden mellan Thread-klassen och Runnable-gränssnittet i Java?

Awesome!

Trådar i Java

Deklarera en tråd i Java

Använda Runnable-gränssnittet

Ärva Thread-klassen

Implementering av Runnable-gränssnittet

Skillnad mellan Thread och Runnable

Metoder tillgängliga för trådar i Java

1. Vad är en tråd i Java?

2. Vad är skillnaden mellan Thread-klassen och Runnable-gränssnittet i Java?