在以往的项目中,我在对数据库进行修改操作时(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;
}
/**
* 插入操作
* <p>Title: insert</p>
* <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<String> queue;
/*
* 线程锁
*/
public static Lock lock;
public static PrintWriter pw;
static{
queue = new LinkedBlockingQueue<String>();
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
通过上面的代码可以看到,我们在将插入请求放入队列之后,就立即响应客户端,而不去管数据是否真实插入与否。虽然这样有一定的风险(我们可以通过前端进行验证,减小这种风险),也市区了实时性,但在某些情况下不失为一个特别的优化手段。第一次写博客,可能语言描述不准确,图也画得不好,希望大家见谅。