Detailed analysis of Java's implementation of asynchronous processing mechanism

This article involves a brief introduction to the asynchronous processing mechanism in Java programming and a related example. I believe that through this article, everyone can have a better understanding of asynchronous processing.

Usually synchronization means that a certain processing process of a task will be processed serially by multiple threads, while asynchronous means that a certain processing process can allow multiple threads to process at the same time. Let's take a look at the details about asynchronous processing.

Asynchronous usually represents better performance, because it relies heavily on buffering, which is a typical practice of using space for time. For example, in computers, cache is used as a CPU and disk IO The buffer zone coordinates the high-speed computing power of the CPU and the low-speed reading and writing capabilities of the disk.

volatile

## Application scenario: Check the execution shutdown or interruption status of an application. Because this keyword rejects the virtual optimization of multiple assignments to a variable, it ensures that the virtual machine will definitely check the state changes of the variables modified by this keyword.

CountDownLatch
## Application scenario: Control the current thread to wait until a group of thread operations are completed. For example, executing the await() method in the main thread blocks the main thread, and executing the countDown() method after the worker thread finishes executing the logic.

Example scenario in this article:

1. Send a message from the console to the message server (simulated by a queue).

2. Write the message queue to the file (set a delay for the file writing operation to simulate the performance bottleneck).

3. The message server acts as a buffer between the console and file writing.

Sample code:

Note: Adding messages to the message queue can be added at once through the for loop. This article is for the convenience of observing the files and queues. The change uses console input. The actual writing speed of a line of file recording should be higher than the hand speed, so the thread sleep time is increased in the example of this article.

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

Summary

The above is the detailed content of Detailed analysis of Java's implementation of asynchronous processing mechanism. For more information, please follow other related articles on the PHP Chinese website!