Dieser Artikel enthält eine kurze Einführung in den asynchronen Verarbeitungsmechanismus in der Java-Programmierung und ein entsprechendes Beispiel. Ich glaube, dass jeder durch diesen Artikel ein besseres Verständnis der asynchronen Verarbeitung erlangen kann.
Normalerweise bedeutet Synchronisation, dass ein bestimmter Verarbeitungsprozess einer Aufgabe seriell von mehreren Threads verarbeitet wird, während asynchron bedeutet, dass ein bestimmter Verarbeitungsprozess die gleichzeitige Verarbeitung mehrerer Threads ermöglichen kann. Werfen wir einen Blick auf die Details der asynchronen Verarbeitung.
Asynchron stellt normalerweise eine bessere Leistung dar, da es stark auf Pufferung angewiesen ist, was eine typische Praxis bei der Verwendung von Speicherplatz für Zeit ist. In Computern wird der Cache beispielsweise als CPU und Festplatten-E/A-Puffer verwendet Die Zone koordiniert die Hochgeschwindigkeits-Rechenleistung der CPU und die langsamen Lese- und Schreibfähigkeiten der Festplatte.
flüchtig
Anwendungsszenario: Überprüfen Sie den Ausführungs-Abschalt- oder Unterbrechungsstatus einer Anwendung. Da dieses Schlüsselwort die virtuelle Optimierung mehrerer Zuweisungen an eine Variable ablehnt, stellt es sicher, dass die virtuelle Maschine die Zustandsänderungen der durch dieses Schlüsselwort geänderten Variablen auf jeden Fall überprüft.
CountDownLatch
Anwendungsszenario: Steuern Sie, dass der aktuelle Thread wartet, bis eine Gruppe von Thread-Vorgängen abgeschlossen ist. Wenn Sie beispielsweise die Methode „await()“ im Hauptthread ausführen, wird der Hauptthread blockiert, und wenn Sie die Methode „countDown()“ ausführen, nachdem der Arbeitsthread die Ausführung der Logik abgeschlossen hat.
Beispielszenario in diesem Artikel:
1. Senden Sie eine Nachricht von der Konsole an den Nachrichtenserver (simuliert durch eine Warteschlange).
2. Schreiben Sie die Nachrichtenwarteschlange in die Datei (legen Sie eine Verzögerung für den Dateischreibvorgang fest, um den Leistungsengpass zu simulieren).
3. Der Nachrichtenserver fungiert als Puffer zwischen der Konsole und dem Dateischreiben.
Beispielcode:
Hinweis: Das Hinzufügen von Nachrichten zur Nachrichtenwarteschlange kann auf einmal über eine for-Schleife hinzugefügt werden. Dieser Artikel ist für Bequemlichkeit der Beobachtung der Dateien und Warteschlangen. Die tatsächliche Schreibgeschwindigkeit einer Dateiaufzeichnung sollte höher sein als die Handgeschwindigkeit, daher wird die Thread-Ruhezeit im Beispiel dieses Artikels erhöht.
package org.wit.ff.ch2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
*
* <pre class="brush:php;toolbar:false">
* 简单异步处理示例.
*
*
* @author F.Fang
* @version $Id: AsyncHandler.java, v 0.1 2014年10月23日 下午11:37:54 F.Fang Exp $
*/
public class AsyncHandler {
/**
* 控制资源释放.
*/
private CountDownLatch latch;
/**
* 处理完成标识.
*/
private volatile boolean handleFinish;
/**
* 消息写入本地文件完成.
*/
private volatile boolean sendFinish;
/**
* 阻塞队列.
*/
private BlockingQueue
queue;
private BufferedWriter bw;
public AsyncHandler(CountDownLatch latch) {
this.latch = latch;
/**
* 使用链表实现.
*/
queue = new LinkedBlockingQueue();
File file = new File("E:/hello.txt");
try {
bw = new BufferedWriter(new FileWriter(file));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void handle() {
// 模拟性能瓶颈的执行过程,3s处理一条消息.
new Thread() {
public void run() {
while (!handleFinish) {
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e1) {
// 不做处理.
}
String s = queue.peek();
if (s != null) {
queue.poll();
try {
bw.write(s);
bw.newLine();
} catch (IOException e) {
}
}
// 若队列为空并且消息发送完成.
if (queue.isEmpty() && sendFinish) {
// 计数器1->0
latch.countDown();
// 让处理过程结束.
handleFinish = true;
break;
}
}
}
}.start();
}
/**
*
*
* 给出消息发送完成的标识.
*
*
*/
public void sendFinish() {
sendFinish = true;
}
/**
*
*
* 资源释放.
*
*
*/
public void release() {
System.out.println("release!");
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
// TODO 打印日志.
}
}
//其实使用queue = null就够了.
if (queue != null) {
queue.clear();
queue = null;
}
}
/**
*
*
* 往队列发送消息.
*
*
* @param text
*/
public void sendMsg(String text) {
if (text != null && !text.isEmpty()) {
queue.add(text);
}
}
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(1);
AsyncHandler handler = new AsyncHandler(latch);
handler.handle();
// 做一次检查.
Scanner scanner = new Scanner(System.in);
while (true) {
String text = scanner.next();
// 若用户选择退出.
if ("exit".equals(text)) {
// 表示消息已经发送完成.
handler.sendFinish();
break;
}
handler.sendMsg(text);
}
try {
// 阻塞主线程等待消息写入到本地文件完成.
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 释放资源 文件流,队列.
handler.release();
// 关闭控制台输入.
scanner.close();
}
}Nach dem Login kopieren
Zusammenfassung
Das obige ist der detaillierte Inhalt vonDetaillierte Analyse der Java-Implementierung des asynchronen Verarbeitungsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
