Thread-Parallelität in Java

Thread-Parallelität oder Multithreading in fortgeschrittenem Java ermöglicht die gleichzeitige Ausführung mehrerer Threads und verbessert so die Leistung und Reaktionsfähigkeit in komplexen Anwendungen. Hier ist eine kurze Aufschlüsselung der wichtigsten Konzepte und Dienstprogramme.

Hauptmerkmale von Multithreading in Java:

1. Threads erstellen.
2. Thread-Management mit Executors
3. Parallelitätsdienstprogramme
4. Fork/Join-Framework
5. Asynchrone Programmierung mit vollständiger Zukunft

1️⃣ Threads erstellen.

• Thread erweitern: Erstellen Sie einen neuen Thread, indem Sie die run()-Methode überschreiben.

• Runnable implementieren: Übergeben Sie eine Runnable-Instanz an ein Thread-Objekt.

• Implementieren von Callable: Im Gegensatz zu Runnable ermöglicht Callable Threads, ein Ergebnis zurückzugeben und geprüfte Ausnahmen zu behandeln.

2️⃣ Thread-Management mit Executors.

• Java’s Executor Framework (java.util.concurrent.ExecutorService) verwaltet Thread-Pools und ermöglicht so eine effiziente Bearbeitung von Aufgaben.

• Ausführer wie FixedThreadPool und CachedThreadPool erstellen einen Pool wiederverwendbarer Threads und verwalten diese effizient, um den Aufwand für die Erstellung neuer Threads zu reduzieren.

3️⃣ Parallelitätsdienstprogramme

• Sperren: Erweiterte Sperrmechanismen wie ReentrantLock bieten mehr Flexibilität als synchronisierte Methoden und ermöglichen zeitgesteuerte und unterbrechbare Sperren.

• Atomvariablen: Das Paket java.util.concurrent.atomic enthält atomare Klassen (AtomicInteger, AtomicLong), die sperrenfreie Threads bieten.
  sicheren Betrieb.

• Synchronisatoren: umfassen Dienstprogramme wie:
  CountDownLatch: Ermöglicht einem Thread zu warten, bis andere Threads abgeschlossen sind
  Aufgaben.
  CyclicBarrier: Synchronisiert eine feste Anzahl von Threads an einem gemeinsamen
  Barrierepunkt.
  Semaphor: Steuert den Zugriff auf Ressourcen durch Zulassen einer bestimmten Nummer
  von gleichzeitigen Threads.

4️⃣ Fork/Join-Framework

• 1. Bei Divide-and-Conquer-Aufgaben teilt ForkJoinPool eine Aufgabe in kleinere Teilaufgaben auf, die parallel verarbeitet werden, was besonders nützlich bei rekursiven Algorithmen ist.

5️⃣ Asynchrone Programmierung mit vollständiger Zukunft

• CompletableFuture ermöglicht asynchrone und nicht blockierende Programmierung und ermöglicht die Verkettung und Kombination von Aufgaben für komplexe Arbeitsabläufe.

Thread-Beispiel verwenden

Hauptklasse ruft 2 verschiedene Threads auf

public class ThreadConcurrence {
    public static void main(String[] args) {
        // There is 2 type you have to call thread method
                //1- Extend Thread class
                //1- Implements Runnable class
        // why Implement concept is introduce here
                // because in java multiple thread dose not support that's so why implement class will introduce
                // ex- when u extend (inherit) base call, then at that time this call can not extend another Thread class.
        int n = 10;
        for (int i = 0; i < n; i++) {

            // in case of extend(inherit) Thread class
            Thread1 t1 = new Thread1();
            t1.start();

            // in case of implement Runnable class
            Thread t2 =new Thread(new Thread2());
            t2.start();
        }
    }
}

Thread1--(erweitert Thread)

public class Thread1 extends Thread{
    //If you are extend Thread class then you  most be used run()
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread1 is running now....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Thread2--(implementiert Runnable)

public class Thread2 implements Runnable {
    //IF you are implement thread Then run() will be executed.
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread2 is running.......");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Fazit:

Durch die Nutzung dieser Tools und Frameworks ermöglicht fortschrittliches Java-Multithreading die Erstellung skalierbarer, leistungsstarker Anwendungen, die gleichzeitige Aufgaben nahtlos bewältigen können.

Für weitere Einblicke können Sie gerne Ihr Linkedin und GitHub erwähnen, um ausführliche Beispiele und Codebeispiele zu erhalten! Lassen Sie mich wissen, wenn Sie spezifische Anpassungen wünschen.

Linkedin: https://www.linkedin.com/in/pravanjan-17p/

GitHub: https://github.com/Prabhanjan-17p

Das obige ist der detaillierte Inhalt vonThread-Parallelität in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!