Java-Multithread-Programmierung: Thread-Erstellung, Synchronisierung und Kommunikation

Java-Multithread-Programmierung: Thread-Erstellung, Synchronisierung und Kommunikation

Als objektorientierte Programmiersprache unterstützt Java Multithread-Programmierung und kann komplexe Probleme mit der Parallelität mehrerer Aufgaben bewältigen. Durch die Zerlegung eines Programms in mehrere Ausführungsthreads zur gleichzeitigen Ausführung von Aufgaben kann die Multithread-Programmierung von Java die Leistung des Programms erheblich verbessern.

In Java ist ein Thread ein einfacher Ausführungspfad, der Speicher und andere Ressourcen mit anderen Threads teilt. Jeder Thread führt seine eigenen Aufgaben unabhängig aus, aber Threads können Ressourcen durch Synchronisierung und Kommunikation koordinieren und gemeinsam nutzen.

Erstellung von Threads
Es gibt zwei Möglichkeiten, Threads in Java zu erstellen: die Thread-Klasse erben und die Runnable-Schnittstelle implementieren.

Erben Sie die Thread-Klassenmethode:

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running.");
    }
}

Implementieren Sie die Runnable-Schnittstellenmethode:

public class MyRunnable implements Runnable{
    public void run(){
        System.out.println("MyRunnable is running.");
    }
}

Die Thread-Startmethode lautet wie folgt:

// 继承Thread类方式
Thread thread1 = new MyThread();
thread1.start();

// 实现Runnable接口方式
Thread thread2 = new Thread(new MyRunnable());
thread2.start();

Thread-Synchronisation
Da bei der Java-Multithread-Programmierung die Ausführungsreihenfolge zwischen Threads unvorhersehbar ist, Wenn also mehrere Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen, kann es zu Datenwettlaufproblemen kommen, die zu falschen Programmergebnissen führen.

Um eine korrekte Koordination und Datenfreigabe zwischen Threads sicherzustellen, werden in Java Synchronisationsmechanismen und Objektsperren bereitgestellt. Der Synchronisationsmechanismus wird über das synchronisierte Schlüsselwort implementiert, und der Sperrmechanismus wird über das Sperrobjekt in Java implementiert.

So verwenden Sie das synchronisierte Schlüsselwort:

public class MyCounter {
    private int count;

    public synchronized void increment() {
        count++;
    }
}

Im obigen Code ist die Methode increment() eine threadsichere Methode, d. h. nur ein Thread kann auf diese Methode zugreifen zur gleichen Zeit. increment()方法为线程安全方法，即在同一时刻只有一个线程能够访问该方法。

下面是lock对象的使用方式：

public class MyCounter {
    private int count;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

上述代码中，increment()方法同样是线程安全方法，为了保证线程安全，需要先通过lock()方法获得对象锁，然后执行完操作后再释放对象锁。

线程通信
通过线程同步机制可以保证线程安全，但是有些情况下需要线程间的协调和信息交换，这时就需要线程通信机制。线程通信机制包括wait()、notify()和notifyAll()三个方法。

wait()方法使当前线程等待，并将线程的状态设置为等待状态，直到另一个线程使用notify()方法通知或者wait()时间超时。

notify()方法则唤醒一个等待状态的线程，如果有多个线程在等待状态，只能随机选择其中的一个线程唤醒。

notifyAll()方法唤醒所有等待状态的线程，这样多个等待状态的线程就能够同时运行。

下面是线程通信的示例：

public class MyQueue {
    private Queue<String> queue = new LinkedList<>();

    public synchronized void put(String value) {
        queue.add(value);
        notify();
    }

    public synchronized String get() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }
        return queue.remove();
    }
}

上述代码中，put()方法将元素添加到队列中，并使用notify()方法通知等待的线程；get()方法则等待队列中的元素，在元素可获得时使用notify()

rrreee
Im obigen Code ist die Methode increment() auch eine Thread-sichere Methode. Um die Thread-Sicherheit zu gewährleisten, müssen Sie dies tun Übergeben Sie zuerst lock(). Die Methode code> erhält die Objektsperre und gibt sie dann nach Abschluss des Vorgangs frei.

Das obige ist der detaillierte Inhalt vonJava-Multithread-Programmierung: Thread-Erstellung, Synchronisierung und Kommunikation. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!