在以往的项目中，我在对数据库进行修改操作时（cud），往往采用的是同步的方式，这种方式虽然很直观，但是当并发量达到一定的数目是，这种操作会很花费时间（想象一下，假如你的服务器1秒只能插入100条数据，但是现在每秒中却来了1000个插入请求）这时用户在页面进行操作时，响应时间会非常的长（可能会响应10多秒），严重影响了用户体验。这时候我们就可以采用异步的方式来“欺骗”用户（对，你没有看错，是欺骗哦。），达到优化的目的。
让我们来看看以往的同步模型
我们再以代码的方式模拟一下，下面的代码主要是开启5条线程向文件里面写入数据，来模拟客户端插入请求，为了模拟数据库插入困难，每次写入我们让线程睡眠5秒
package queue;import java.io.FileNotFoundException;import java.io.PrintWriter;import java.util.Date;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Sync implements Runnable{ //线程锁 public static Lock lock; //打印流， public static PrintWriter pw; static{ lock = new ReentrantLock(); try { pw = new PrintWriter("test.txt"); } catch (FileNotFoundException e) { e.printStackTrace(); } } //要写入的信息 private String text; public Sync(String text) { this.text = text; } /** * 插入操作 * Title: insert<／p> *
Description: <／p> */ public void insert(){ try { lock.lock(); pw.println(text); System.out.println("插入成功"+"time :"+new Date().toLocaleString()); //睡眠5秒 TimeUnit.SECONDS.sleep(5); } catch (Exception e) { e.printStackTrace(); }finally{ lock.unlock(); } } @Override public void run() { this.insert(); } public static void main(String[] args) { //创建5个线程，用于模拟并发 ExecutorService es = Executors.newFixedThreadPool(5); for( int i=0;i<5;i++ ){ es.execute(new Sync(i+"条数据")); } es.shutdown(); }}
执行结果
插入成功time :2014-11-19 22:51:28
插入成功time :2014-11-19 22:51:33
插入成功time :2014-11-19 22:51:38
插入成功time :2014-11-19 22:51:43
插入成功time :2014-11-19 22:51:48
可以看到，当入库请求并发量很大时，同步插入所等待的时间非常的长，这样就会严重的影响用户体验。于是为了解决这个问题，我们就可以尝试使用异步的方式来进行数据插入。
先让我们来看一下异步的模型
异步插入的思想主要是，在得到客户端请求时，并不会将数据插入之后才响应客户端。而是将sql语句，与要用的参数打包，放进一个队列（queue）中，然后立即响应客户端。后台会有一个专门的模块（类似于sqlLoader）专门从队列中取数据，并进行插入。所以图中前面部分的1,2,3步，与后面的1,2,是同时进行的。这样就极大的提高了响应速度，但是也带来的一些问题，例如：你服务器在响应之后（也就是，客户端给出了“操作成功”），但是入库模块在入库是却出现了错误，导致数据没有插入进去。其次，这样做也会失去实时性 。
下面就通过一段代码来演示一下：
import java.io.FileNotFoundException;import java.io.PrintWriter;import java.util.Date;import java.util.concurrent.BlockingQueue;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Asyn implements Runnable{ /* * 用于存放要插入的数据 */ public static BlockingQueue queue; /* * 线程锁 */ public static Lock lock; public static PrintWriter pw; static{ queue = new LinkedBlockingQueue (); lock= new ReentrantLock(); try { pw = new PrintWriter("test.txt"); } catch (FileNotFoundException e) { e.printStackTrace(); } } public void insert(){ try { lock.lock(); String data = queue.take(); pw.println(data); pw.flush(); System.out.println("真正插入数据："+data+" time:"+new Date().toLocaleString()); //为了模拟插入吃力，睡眠5s TimeUnit.SECONDS.sleep(5); } catch (Exception e) { e.printStackTrace(); }finally{ lock.unlock(); } } public static void main(String[] args) throws InterruptedException, ExecutionException { //模拟服务器讲sql请求放入队列后，立即响应客户端。 for( int i=0;i<5;i++ ){ queue.add(i+"条数据"); System.out.println("我把数据"+i+ "放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:"+new Date().toLocaleString()); } //模拟入库模块入库 ExecutorService es = Executors.newSingleThreadExecutor(); es.execute(new Asyn()); } public void run() { while( true ){ insert(); } }} 执行结果如下：
我把数据0放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:2014-11-20 9:55:15
我把数据1放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:2014-11-20 9:55:15
我把数据2放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:2014-11-20 9:55:15
我把数据3放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:2014-11-20 9:55:15
我把数据4放进了队列，虽然数据没有真正插入，但我已经响应客户端了。 time:2014-11-20 9:55:15
真正插入数据：0条数据 time:2014-11-20 9:55:15
真正插入数据：1条数据 time:2014-11-20 9:55:20
真正插入数据：2条数据 time:2014-11-20 9:55:25
真正插入数据：3条数据 time:2014-11-20 9:55:30
真正插入数据：4条数据 time:2014-11-20 9:55:35
通过上面的代码可以看到，我们在将插入请求放入队列之后，就立即响应客户端，而不去管数据是否真实插入与否。虽然这样有一定的风险（我们可以通过前端进行验证，减小这种风险），也市区了实时性，但在某些情况下不失为一个特别的优化手段。第一次写博客，可能语言描述不准确，图也画得不好，希望大家见谅。