http请求不占用并发资源的同步操作

在并发环境下，对竞态资源的同步操作，肯定是会造成多个线程的阻塞，而在一个系统中并发线程数是有限的，对一个资源的同步阻塞，势必会造成其他资源的操作请求无法进入系统。

 

如：用户的余额，操作通用用户的余额肯定是同步操作，初期的解决办法是通过加锁同步用户余额操作。

synchronized (userId) {//给用户id常量加锁余额操作业务}

上述代码看似是锁住的是一个用户，对其他用户不受影响，但是它的并发操作会占用servlet request的多个请求资源，而tomcat等服务器的请求资源是有限的，这样是会导致其他用户的请求被阻塞在tomcat之外。

上述request请求和业务操作其实是生产者和消费者的关系，上述处理由于生产者和消费者是在同一线程中，因此它们的处理能力是相互影响的。

那怎么才能让http request请求和业务操作不在一个线程中，防止同步操作对request资源的占用。Servelet 3.0的横空出世解决了这个问题，它可以异步处理request返回response信息。

new Thread(new Runnable() {public void run() {获取异步requestsynchronized (userId) {//给用户id常量加锁余额操作业务}异步输出response}}).start();

那用上述代码使http request不阻塞，而且http request请求和业务操作不在一个线程中，这样是不是就不会占用并发资源？

答案是否定的。作为消费者的业务处理会产生同步阻塞，这样消费者的能力受限，生产者接受到的request请求再多，消费者业务处理跟不上，系统同样是受限的。

那怎么让消费者和生产者都不受限呢？

上述问题的根源在于同步操作对多个线程的占用阻塞，那我们就把同步操作放到一个线程中，不产生多个线程的阻塞，问题不就解决了嘛

public class QueueTread {private static final Map<String, QueueTread> map=new HashMap<>();private Queue<RequestO> queue=null;private boolean busy;private String uniquekey;@Resource(name="myThreadPool")//不起作用,因为QueueTread不是通过注解生成的public  TaskExecutor myThreadPool;private volatile int i=0;private volatile int j=0;private QueueTread(Queue<RequestO> queue,TaskExecutor myThreadPool,String uniquekey) {super();this.queue = queue;this.myThreadPool=myThreadPool;this.uniquekey=uniquekey;}private  void add(RequestO o){if(queue.offer(o)==false){System.err.println(uniquekey+"入队失败");}System.out.println(uniquekey+"入队列="+(++j));if(busy==false){//synchronized (uniquekey) {//if(busy==false){busy=true;

//为每一个队列申请空闲线程myThreadPool.execute(new Runnable() {public void run() {RequestO o=null;

//循环操作需要同步的功能while((o=queue.poll())!=null){//if(o.getDeferredResult().isSetOrExpired()){//continue;//}System.out.println(uniquekey+"出队列="+(++i));try {o.getCallable().call();//业务回调} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}synchronized (uniquekey) {if (queue.isEmpty()) {busy=false;

//释放处理完毕的队列Object xObject=map.remove(uniquekey);System.out.println(uniquekey+"队列移除"+xObject);}}if(busy){

//此处递归，是为了防止在释放队列前有queuethread.add(requestO)run();}}});//}//}}}public static void accept(String uniquekey,RequestO requestO,TaskExecutor myThreadPool){synchronized (uniquekey) {if (map.get(uniquekey)==null) {//为同步操作资源创建队列map.put(uniquekey, new QueueTread(new LinkedList<>(),myThreadPool,uniquekey));}QueueTread queuethread=map.get(uniquekey);//将请求和业务处理操作放到线程中queuethread.add(requestO);}}}

上述代码就是把对同一资源uniquekey的操作放到一个队列中，用同一个线程处理每一个队列，这样就不会造成并发线程的阻塞操作。所有需要同步的操作只要调用accet方法就可以。

 

以下是封装request请求和业务处理回调的类。

public class RequestO {private HttpServletRequest request;private HttpServletResponse response;private DeferredResult<Object> deferredResult;private Callable<Object> callable;public HttpServletRequest getRequest() {return request;}public void setRequest(HttpServletRequest request) {this.request = request;}public HttpServletResponse getResponse() {return response;}public void setResponse(HttpServletResponse response) {this.response = response;}public DeferredResult<Object> getDeferredResult() {return deferredResult;}public void setDeferredResult(DeferredResult<Object> deferredResult) {this.deferredResult = deferredResult;}public Callable<Object> getCallable() {return callable;}public void setCallable(Callable<Object> callable) {this.callable = callable;}}