精华内容
下载资源
问答
  • 多个请求请求同一方法
    千次阅读
    2018-09-21 18:35:27

    有个小伙子告诉我,一个页面上同时开启多个ajax,向后台请求数据,会被堵塞。
    “因为是同一个会话。但如果在控制器上加上这个特性就可以了”,小伙子说。

        //session只读,避免同一会话中session锁导致请求阻塞
        [SessionState(System.Web.SessionState.SessionStateBehavior.ReadOnly)]
        public class CxController : BaseLT.Web.UserControllerBase
        {
        。。。。
        }
    

    经测试,还真是。如果没有这个特性,多个ajax请求到了后台,原本是并发的,结果变成了队列,一个接一个地完成。如果加上,则是并行完成。
    个中原因,可以看以下参考资料:
    ASP.net Session阻塞、Session锁、MVC Action请求阻塞问题

    HttpSessionState来自于HttpModule的SessionStateModule。在每次请求处理过程中,HttpApplication的请求的处理管道中会检查当前请求的处理程序是否实现了接口IRequiresSessionState,如果实现的话,那么SessionStateModule将为这个请求分配HttpSessionState。同时SessionStateModule还负责SessionID的生成、Cookieless会话管理、从外部状态提供程序中检索会话数据以及将数据绑定到请求的调用上下文。
    如果页面请求设置一个读取器锁定,同一会话中同时处理的其他请求将无法更新会话状态,但是至少可以进行读取。如果页面请求为会话状态设置一个写入锁,那么所有其他页面都被阻止,无论他们是否要读取或写入内容。例如,如果同时有两段程序视图在同一个Session中写入内容,一段程序必须等到另一段程序完成后才能写入。在AJAX程序设计中,必须注意这种情况的发生。

    我只想说,后生可畏。

    更多相关内容
  • 再测试这个问题的时候,遇到了一个问题,就是同一浏览器(谷歌),多次测试(开了多个tab页),发现多次请求同一方法,执行时顺序执行,即第一个请求执行完毕,第二个请求才开始执行 当打开QQ浏览器时,才能并发执行...

    首先要确保这些请求不是同一请求:

    再测试这个问题的时候,遇到了一个问题,就是同一浏览器(谷歌),多次测试(开了多个tab页),发现多次请求同一方法,执行时顺序执行,即第一个请求执行完毕,第二个请求才开始执行

    当打开QQ浏览器时,才能并发执行

    此问题,其实还是session问题导致的,同一浏览器多次请求同一个方法(域名、地址都相同),会被认为是同一个用户多次请求,因此是顺序执行;当用其他浏览器打开时,session不一样了,会认为是其他用户登录系统执行操作,因此是并发执行代码

    例图:
    在这里插入图片描述

    展开全文
  • 3. 用户快速频繁的操作,导致了次发送同一接口不同参数的请求。 4. 后台接口由于不同参数的查询操作导致数据响应时间差异大。 如果用户没有快速操作,每次请求发送的时间有一定间隔,这时即使接口响应时间略有...

    问题的发现

    在前端开发过程中,曾经遇到过两次bug,经过排查以后,发现产生bug的原因应该是差不多的,所以想总结一下。
    具体的场景如下:

    1. 下图中搜索框是实时搜索的,当输入“2”的时候,传参是“2”,请求一次接口;当在“2”的基础上继续输入“3”时,传参是“23”,再一次请求接口。当用户快速的不停的来回输入“2”和“23”时,前端界面数据渲染会出现错乱的情况,明明输入的是“23”,但是前端界面渲染的却是输入为“2”的内容。
      搜索
    2. 下图是tab页导航,当不停的来回切换tab页的时候,前端界面数据渲染也会出现错乱的情况,即明明点击的是第二个tab导航,但是前端界面渲染的确是第一个tab页里面的内容。
      tab页导航

    经过排查问题,发现引发上面两种情况的原因本质是一样的:
    3. 用户快速频繁的操作,导致了多次发送同一接口不同参数的请求。
    4. 后台接口由于不同参数的查询操作导致数据响应时间差异大。

    如果用户没有快速操作,每次请求发送的时间有一定间隔,这时即使接口响应时间略有差异,也不会出现上述bug。如果后台数据响应时间差异很小,即使用户快速操作也不会出现上述bug。正是由于以上1、2两个原因共同作用导致了bug的出现。

    解决方案

    在网上搜了很多关于这种数据渲染错乱的解决方案,都没有找到合适的,最后参考了这篇博客,该博客描述的问题和我遇到的问题相似,博客地址是:https://blog.csdn.net/qq_19891827/article/details/82757250

    这篇文章举了一个例子:假设页面上有button1,button2两个按钮,点击这两个按钮会请求同一个后台接口,但发送的参数不同,由于参数的不同后台操作数据库的查询语句会有一定差异,这就导致了不同的查询操作耗时可能差异巨大。再假设button1发送的参数响应的时间为2秒,button2发送的参数响应时间为1秒,用户快速先后点击了button1和button2按钮。这时会先后发送两个ajax请求,过了1秒后button2的响应数据先返回渲染到DOM上,又过了1秒后button1的响应数据返回后渲染到DOM覆盖button2的数据。而这时用户页面button2由于是后点击的,处于选中状态,用户期望查看button2对应的数据,但是最后却展示button1按钮的数据,这与用户的期望不符合,是一个严重的bug。

    在进行前端开发过程中,经常会遇到需要请求同一个数据接口但不同参数的需求,这种情况下当用户通过页面操作频繁请求该接口,而接口的不同参数响应时间差异较大时,容易引发数据渲染混乱的bug。针对这种问题,有三种解决方案:

    方案一:限制用户快速进行同类操作,当用户通过操作触发了一次请求后,将同类的操作按钮禁用,成功响应数据后再将按钮解除禁用。示例代码如下:

    <template>
         <div>
          <button @click="sendReq" :disabled="isDisabled">button1</button>
          <button @click="sendReq" :disabled="isDisabled">button2</button>
          <p>{{content}}</p>
         </div>
       </template>
       <script>
         export default {
           data(){
             return {
               isDisabled : false,  //控制按钮可用性
               content : '' //响应数据内容
             }
           }
         }
         methods : {
           sendReq(){
             this.isDisabled = true; //禁用操作按钮
             this.$axios.get('/xxxx?id=1').then(response=>{
               this.isDisabled = false;
               this.content = response.content;
    	 })
           }
         }
       </script>
    

    这种方案优点是简单粗暴,缺点是如果数据响应时间较长时,用户体验不好。

    方案二:分析用户行为会发现,用户快速操作同一接口后,只希望得到最后一次操作的数据。由此想到当用户快速操作同一接口时,只发送最后一次操作的ajax请求,即可在一定程度上解决该bug。这里我设置一个名为timer的500毫秒的一次性定时器,每次用户操作时首先清除没有执行timer定时器,然后通过timer定时器延迟500毫秒执行ajax请求,这样用户在500毫秒内执行的相同操作时,没执行的timer定时器被清理,始终只会保留最后一次操作的ajax请求,500毫秒内没有相同操作时,会发送该请求。代码如下:

    <template>
     <div>
       <button @click="sendReq">button1</buttono>
       <button @click="sendReq">button2</button>
       <p>{{content}}</p>
     </div>
    </template>
    <script>
     export default {
      data(){
       return {
        timer : null, //定义定时器用
        content : '', //响应数据内容
       }
      }
     }
     methods : {
      sendReq(){
       clearTimerout(this.timer);  //清除没执行的timer定时器
       this.timer = setTimeout(()=>{ //定义一个timer定时器,延迟执行ajax请求
        this.$axios.get('/xxxx?id=1').then(response=>{
         this.content = response.content;
        })
       }, 500)
      }
     }
    </script>
    

    上述方案可以减少无用的ajax请求,节省性能;同时也可以在一定程度上解决上述bug,但并不能完全避免,该方案相当于设置了500毫秒的容差,可以解决后台数据响应时间差距在500毫秒以内产生的bug;当后台数据响应时间差距大与500毫秒时,仍然无法避免上述bug。在此基础上我们有了进一步的解决方案。

    方案三:做一个计时器,初始值为0,每一次发送ajax请求前为计时器做一个递加操作,发送ajax请求时将该值作为参数传给后台,接收响应数据时后台将该值再返回来,我们根据前端存储的计数器的值与后端返回来的值作比较,只有二者相等时说明返回的是最后一次用户操作的数据。如二者不相等,则返回的数据不是最后一次操作的数据。至此该bug完全解决。代码如下:

    <template>
     <div>
      <button @click="sendReq">button1</button>
      <button @click="sendReq">button2</button>
      <p>{{content}}</p>
     </div>
    </template>
    <script>
     export defalut {
      data(){
       return {
        timer : null, //定义定时器
        counter : 0, //计时器
        content : '', //响应数据内容
       }
      }
     }
     methods : {
      clearTimerout(this.timer); //清除没执行的timer定时器
      this.counter++;
      this.timer = setTimeout(()=>{//定义一个timer定时器,延迟执行ajax请求
       this.$axios.get(`/xxxx?id=1&counter=${this.counter}`).then(resonse=>{
        if(response.counter < this.counter){ //后台返回的counter字段值与前端存储的计数器值做比较,如果不相等,这说明返回的数据不是用户最后一次操作的数据。因此不渲染数据到DOM上
          return;
        }
        this.content = response.content;
       })
      }, 500)
     }
    </script>
    

    上述三种解决方案,我选择的是方案二,比较简单也基本满足修复我遇到的bug。

    展开全文
  • 1、线程工具TreadTestHttp package com; import java.util.concurrent.CountDownLatch; public class TreadTestHttp { public static void main(String[] args) throws InterruptedException { Runn...

    1、多线程工具TreadTestHttp 

    package com;
    
    import java.util.concurrent.CountDownLatch;
     
    public class TreadTestHttp {
     
        public static void main(String[] args) throws InterruptedException {
            Runnable taskTemp = new Runnable() {
    	// 注意,此处是非线程安全的,留坑
                private int iCounter;
     
                @Override
                public void run() {
                    for(int i = 0; i < 1; i++) {
                        // 发起请求
                        String r = HttpClientUtil.doGet("http://localhost:9999/fxcrs/test/test");
                        System.out.println("请求结果="+r);
                        iCounter++;
                        System.out.println(System.nanoTime() + " [" + Thread.currentThread().getName() + "] iCounter = " + iCounter);
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            TreadTestHttp latchTest = new TreadTestHttp();
            // 模拟同时开7个线程访问
            latchTest.startTaskAllInOnce(7, taskTemp);
        }
        public long startTaskAllInOnce(int threadNums, final Runnable task) throws InterruptedException {
            final CountDownLatch startGate = new CountDownLatch(1);
            final CountDownLatch endGate = new CountDownLatch(threadNums);
            for(int i = 0; i < threadNums; i++) {
                Thread t = new Thread() {
                    public void run() {
                        try {
                            // 使线程在此等待,当开始门打开时,一起涌入门中
                            startGate.await();
                            try {
                                task.run();
                            } finally {
                                // 将结束门减1,减到0时,就可以开启结束门了
                                endGate.countDown();
                            }
                        } catch (InterruptedException ie) {
                            ie.printStackTrace();
                        }
                    }
                };
                t.start();
            }
            long startTime = System.nanoTime();
            System.out.println(startTime + " [" + Thread.currentThread() + "] All thread is ready, concurrent going...");
            // 因开启门只需一个开关,所以立马就开启开始门
            startGate.countDown();
            // 等等结束门开启
            endGate.await();
            long endTime = System.nanoTime();
            System.out.println(endTime + " [" + Thread.currentThread() + "] All thread is completed.");
            return endTime - startTime;
        }
    }

    2、get和post请求工具HttpClientUtil

    package com;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.URL;
    
    class HttpClientUtil {
        public static String doGet(String httpurl) {
            HttpURLConnection connection = null;
            InputStream is = null;
            BufferedReader br = null;
            String result = null;// 返回结果字符串
            try {
                // 创建远程url连接对象
                URL url = new URL(httpurl);
                // 通过远程url连接对象打开一个连接,强转成httpURLConnection类
                connection = (HttpURLConnection) url.openConnection();
                // 设置连接方式:get
                connection.setRequestMethod("GET");
                // 设置连接主机服务器的超时时间:15000毫秒
                connection.setConnectTimeout(15000);
                // 设置读取远程返回的数据时间:60000毫秒
                connection.setReadTimeout(60000);
                // 发送请求
                connection.connect();
                // 通过connection连接,获取输入流
                if (connection.getResponseCode() == 200) {
                    is = connection.getInputStream();
                    // 封装输入流is,并指定字符集
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    // 存放数据
                    StringBuffer sbf = new StringBuffer();
                    String temp = null;
                    while ((temp = br.readLine()) != null) {
                        sbf.append(temp);
                        sbf.append("\r\n");
                    }
                    result = sbf.toString();
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭资源
                if (null != br) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
     
                if (null != is) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
     
                connection.disconnect();// 关闭远程连接
            }
     
            return result;
        }
     
        public static String doPost(String httpUrl, String param) {
     
            HttpURLConnection connection = null;
            InputStream is = null;
            OutputStream os = null;
            BufferedReader br = null;
            String result = null;
            try {
                URL url = new URL(httpUrl);
                // 通过远程url连接对象打开连接
                connection = (HttpURLConnection) url.openConnection();
                // 设置连接请求方式
                connection.setRequestMethod("POST");
                // 设置连接主机服务器超时时间:15000毫秒
                connection.setConnectTimeout(15000);
                // 设置读取主机服务器返回数据超时时间:60000毫秒
                connection.setReadTimeout(60000);
     
                // 默认值为:false,当向远程服务器传送数据/写数据时,需要设置为true
                connection.setDoOutput(true);
                // 默认值为:true,当前向远程服务读取数据时,设置为true,该参数可有可无
                connection.setDoInput(true);
                // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
                connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                // 设置鉴权信息:Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
                connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
                // 通过连接对象获取一个输出流
                os = connection.getOutputStream();
                // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
                os.write(param.getBytes());
                // 通过连接对象获取一个输入流,向远程读取
                if (connection.getResponseCode() == 200) {
     
                    is = connection.getInputStream();
                    // 对输入流对象进行包装:charset根据工作项目组的要求来设置
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
     
                    StringBuffer sbf = new StringBuffer();
                    String temp = null;
                    // 循环遍历一行一行读取数据
                    while ((temp = br.readLine()) != null) {
                        sbf.append(temp);
                        sbf.append("\r\n");
                    }
                    result = sbf.toString();
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭资源
                if (null != br) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != os) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != is) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                // 断开与远程地址url的连接
                connection.disconnect();
            }
            return result;
        }
    }
    

    3、实际的运行效果

    432371083711700 [Thread[main,5,main]] All thread is ready, concurrent going...
    请求结果={"errorText":"同一接口访问上限,请稍后再试","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"bm_code_url_max_count","sEcho":"","iDisplayStart":0}
    
    请求结果={"errorText":"同一接口访问上限,请稍后再试","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"bm_code_url_max_count","sEcho":"","iDisplayStart":0}
    
    请求结果={"errorText":"同一接口访问上限,请稍后再试","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"bm_code_url_max_count","sEcho":"","iDisplayStart":0}
    
    请求结果={"errorText":"同一接口访问上限,请稍后再试","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"bm_code_url_max_count","sEcho":"","iDisplayStart":0}
    
    432371398025100 [Thread-0] iCounter = 3
    432371397965500 [Thread-4] iCounter = 2
    432371397920900 [Thread-1] iCounter = 1
    432371398091600 [Thread-2] iCounter = 4
    请求结果={"errorText":"同一接口访问上限,请稍后再试","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"bm_code_url_max_count","sEcho":"","iDisplayStart":0}
    
    432371398524800 [Thread-6] iCounter = 5
    请求结果={"errorText":"操作成功","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"success","sEcho":"","iDisplayStart":0}
    
    432371410285100 [Thread-3] iCounter = 6
    请求结果={"errorText":"操作成功","iTotalRecords":0,"aaData":"","iTotalDisplayRecords":0,"errorCode":"success","sEcho":"","iDisplayStart":0}
    
    432371410399200 [Thread-5] iCounter = 7
    432371411959300 [Thread[main,5,main]] All thread is completed.

     

    展开全文
  • 我想让这两地址都被一controller方法处理,我实验了一下,不行啊,请同学知道么 @RequestMapping(value={"/details/{actId}", "/details/{actId}/{sku}"}, method = RequestMethod.GET) public String ...
  • el-radio-button切换不同的按钮获取到列表的数据不同,次快速切换偶尔发现显示的数据混乱,解决: 添加定时器: data(){ return { timer: null,//定时器 } }, methods: { //获取列表数据 search (data) { ...
  • 背景:项目中有多个组件调用同一接口,为提高代码可维护性,需要封装公共方法 直接return 接口调用的结果 export function getAll() { let all = []; let opt = { method: 'get', url: 'all/...
  • 需求,某个异步请求函数可能被次调用,重复调用消耗资源,需要对其进行优化 每次调用该函数都能取到返回值 只发送一次异步请求和节流、防抖功能不一样,节流防抖会丢弃掉中间的请求,中间的请求获取不...
  • 首先配置vue.config.js文件 写好所需要的服务器地址 module.exports = { ... //字段 /api/one 可以自行修改,但是请求数据时,在请求路径上记得要保持一致,请求配置中有写明,请仔细阅读 target: '',//这里填写服
  • 一, 1.创建 “ 线程组 ” 2.设置用户数量 3.给该线程组添加HTTP请求 4.给线程组添加 CSV数据文件设置 ,为了导入参数 5.给HTTP请求添加监控项目 6.查看结果
  • 如果没问题:说明是发送多个ajax请求时,导致数据错乱; 2.解决问题: a.在第一个ajax请求的回调函数中,调用下一个ajax请求(不建议) b.在控制层使用synchronized(一个线程访问一个对象中的synchronized...
  • Servlet都对应一URL地址,可以作为显式URL引用调用,或嵌入在HTML中并从Web应用程序返回
  • Servlet对并发的处理Tomcat容器处理并发采用单例模式、线程处理方式只要webapp被发布到web容器中的时候,servlet只会在发布的时候实例化一次,servlet在其生命周期中只有在将项目给移除或服务器stop的时候才会...
  • 前端请求后端的接口都是正常的操作,但有时往往,前端请求的时候,后端还在处理数据中,可能就有点延迟了一两秒,导致不能实时反馈数据到前端, 用户并不知道这种情况就不断的点击请求,最终出现同一秒同时进了相同...
  • servlet是默认采用单实例,线程的方式进行。只要webapp被发布到web容器中的时候,servlet...出现不同的线程同一时间访问同一servlet的时候,servlet的对象只有一,但是由于是tomcat支持线程的原因,每客户端
  • javascript没有线程这样一说法,其次,不建议使用这种方式解决问题,线程应该交给后台去做 首先我们会想到第一很实际的方式采用 setInterval(function) 定时器异步调用 callee() – 触发函数的自我递归方法 ...
  • 今天遇到一问题需要记录一下 后端开发给了接口,结果在成功和失败的情况下竟然返回的数据类型不一样 失败的情况: { "code": 202, "desc": "格式有误", "result": "核验失败", "success": false } 成功的情况...
  • tomcat会维护一个线程池,多个请求就会分配多个线程处理,一个请求一个线程 可通过修改tomcat的配置改变默认线程的数量 不是线程越多性能越好 同一时间并发执行的线程数量是有限的,不能无限扩展tomcat中的线程,...
  • 同一页面请求完所有接口后再结束loading为例: function1() { return new Promise((resolve, reject) => { request1(requestParams).then((res) => {//接口1 xxx resolve(res); }).catch(e =>{ ...
  • 如果次点击请求同一接口,因为请求是异步的,可能会导致结果最后渲染为上一次搜索的结果,那么如何避免这种情况呢? 第一步:定义一字段num data() { return { num: 0 }; } 第二步:请求接口事件里 this.num...
  • nginx同一域名部署多个vue项目_MQ

    千次阅读 2022-01-16 12:44:58
    nginx同一域名部署多个vue项目_MQ 1、第一个项目正常打包部署,第二个及以上的项目需要设置项目访问路径(请求路径) 第一个正常打包即可 访问时只需要输入域名 :www.xxx.com; 第二个项目访问路径为:...
  • 创建多个线程组,每个线程组下带有一个请求;每个线程组设置一定的并发数(即线程数),用来模拟用户数;ramp-up时间指在N秒内启动这些线程;每个线程组下加一个同步定时器(synchronizing timer),设置模拟数量=...
  • Java实现限制同一ip请求接口的次数

    千次阅读 2022-03-12 13:34:00
    限制接口请求次数的需要在接口请求之前做操作判断,所以可以通过aop或者拦截器来实现 2.具体实现 1.引入相关jar包 expiringmap是可以设置过期时间的map并且线程安全,也可以通过定时任务定时清空普通map <!...
  • Java如何处理大量的并发请求

    千次阅读 2021-03-14 16:48:35
    在web应用中,同一时间有大量的客户端请求同时发送到服务器,例如抢购、秒杀等。这时候如何避免将大量的请求同时发送到业务系统。第一种方法:在容器中配置最大请求数,如果大于改请求数,则客户端阻塞。该方法...
  • java 防止同一IP请求攻击

    千次阅读 2019-03-14 15:37:44
    1. 新增一spring的拦截器 , 拦截所有请求 &lt;!-- 1. 新增一spring的拦截器 , 拦截所有...-- 拦截所有请求,判断是否请求 --&gt; &lt;mvc:mapping path="/*/*" /&gt; ...
  • 用nginx可以限制一IP指定时间段的请求次数 nginx可以限制一IP指定时间段的请求次数 https://blog.csdn.net/xj626852095/article/details/51155875 http{  ...  #定义一名为allips的limit_req_zone用来...
  • java中多个用户在访问同一段代码的时候,后台会为每一个请求分配一个单独的线程来处理,线程之间是相互独立的,互不干扰,当然也可以相互通信。并发问题只有在多个线程之间可能修改同一资源的时候才会出现,解决...
  • 生产环境 nginx.conf # 项目1 server { listen 8089; server_name webapp; #charset koi8-r; #access_log logs/host.access.log main;... root /opt/epidemic_... } } 开发环境跨域proxytable配置 跨域请求第三方api
  • 如果使用同一个浏览器的多个标签页同时访问同一个URL,那么浏览器认为这些不同的请求是同一个人,会对你的每个请求进行排队,不做并发处理。不管Nginx还是Apache,都是在并发处理,只不过你的浏览器自作主张,把你的...
  • 今天想了一问题,静态方法能否被两个方法同时调用的问题,根据网上查的资料是可以同时被调用的,如果不想被同时调用需要加lock锁,进行限制即可。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 524,304
精华内容 209,721
关键字:

多个请求请求同一方法