Nebenläufigkeit / parallele Programmierung🔖

YouTube / Shorts🔖

Definition von Nebenläufigkeit / parallele Programmierung🔖

Definition der Matrixmulitplikation🔖

$\text{Seien } A \in \mathbb{R}^{m \times n}, \, B \in \mathbb{R}^{n \times p}.$

$\text{Dann ist das Matrixprodukt } C = AB \in \mathbb{R}^{m \times p} \text{ definiert durch:}$

$C_{ij} := \sum_{k=1}^{n} A_{ik} B_{kj}, \quad \text{für alle } 1 \leq i \leq m, \, 1 \leq j \leq p.$

Scratch ...

1. 👤 Lege ein neues Java-Projekt MatrixMultiplicationin IntelliJ mit den Klassen Main und MatrixMultiplicator an.

2. 👤 Deklariere die folgenden Instanzvariablen: private int[][] matA, matB, matC für die beiden Eingabematrizen A und B sowie für die Ausgabematrix C. Deklariere eine Integer-Variable matrixSize, die die Größe der Matrix verwaltet.

3. 👤 Implementiere einen Konstruktoren für die Klasse MatrixMultiplicator, der als Parameter die Größe der (quadratischen) Matrizen erwartet. Instanziiere ein Objekt vom Typ MatrixMultiplicator in der Klasse Main.

4. 👤 Implementiere in der Klasse MatrixMultiplicator eine Methode mit dem Methodenkopf public void generateRandomValues(). Diese soll die Matrizen A und B mit zufälligen Werten füllen. Deklariere (private Random rand;), instanziiere (rand = new Random();) und verwende (matA[i][j] = rand.nextInt(10));) dazu ein Objekt vom Typ Random.

5. 👤 Implementiere in der Klasse MatrixMultiplicator eine Methode mit dem Methodenkopf public void displayMatrixA(). Diese soll zeilenweise die Matrix auf der Konsole ausgeben. Erweitere deine Implementierung um eine Methode public void displayMatrixB().

6. 👤 Implementiere die Matrixmultiplikation in einer Methode public void multiplyWithoutThreads.

7. 👤 Teste deine Implementierung in der Klasse Main mit einfachen 2x2-Matrizen, bei denen diu die Lösung händisch überprüfen kannst.

Wir betrachten zunächst die parallelisierte Multiplikation von 3x3-Matrizen mit Hilfe von drei Threads.

1. 👤 Ergänze den folgenden Programmcode der privaten Klasse Worker3x3 und der Methode multiply3x3UsingThreadsin der Klasse MatrixMultiplicator und ergänze die Kommentare.

    
   private class Worker3x3 implements Runnable {
       private int i;
    
       Worker3x3(int pI) {
           i = pI;
       }
    
       public void run() {
           for (int j = 0; j < 3; j++) {
               for (int k = 0; k < 3; k++) {
                   matC[i][j] += matA[i][k] * matB[k][j];
               }
           }
       }
   }
    

    
   public void multiply3x3UsingThreads() {
    
       matC = new int[3][3];
    
       Thread thread0 = new Thread(new Worker3x3(0));
       thread0.start();
    
       Thread thread1 = new Thread(new Worker3x3(1));
       thread1.start();
    
       Thread thread2 = new Thread(new Worker3x3(2));
       thread2.start();
    
       try {
           thread0.join();
           thread1.join();
           thread2.join();
       } catch (Exception e) {
           System.out.println(e.getMessage());
       }
    
   }
    

2. 👤 Füge den folgenden Programmcode in die Klasse M̀ainein und überprüfe, ob die Berechnungen korrekt durchgeführt werden.

    
           MatrixMultiplication myMatrixMultiplicator = new MatrixMultiplication(3);
           myMatrixMultiplicator.generateRandomValues();
           myMatrixMultiplicator.displayMatrixA();
           myMatrixMultiplicator.displayMatrixB();
           myMatrixMultiplicator.multiply3x3UsingThreads();
           myMatrixMultiplicator.displayMatrixC();
    

3. 👤 Ändere das Programm so ab, dass es mit Hilfe von fünf Threads zwei 5x5-Matrizen miteinander multipliziert.

Nun betrachten wir beliebig große Matrizen. Beispielsweise soll die Matrixmultiplikation zweier 500x500-Matrizen mittels 500 Threads realisiert werden.

4. 👤 Modifiziere das Programm geeignet.