精华内容
下载资源
问答
  • 我们产品的 操作台(workbench) 是一个java swing程序.有一个event handler的代码如下:public voidactionPerformed(ActionEvent e) {//做耗时的工作, 如插入数据库}现在的一个问题在于, 如果用户连续点了两次button, ...

    从问题开始说.

    我们产品的 操作台(workbench) 是一个java swing程序. 有一个event handler的代码如下:

    public voidactionPerformed(ActionEvent e) {//做耗时的工作, 如插入数据库

    }

    现在的一个问题在于, 如果用户连续点了两次button, 则event handler被执行两次, 则用户会得到 主键重复错误.

    简单的想法是 在event handler的开头结尾把 对应的ok button给disable/enable.

    public voidactionPerformed(ActionEvent e) {try{//disable OK 按钮...//做耗时的工作

    } finally{//enable OK 按钮...

    }

    }

    但上面这段代码是错误的.

    event dispatch thread的工作流程:

    enter handling code of event1 -> disable button -> enable button -> enter handling code of event2

    正确的实现:

    public voidactionPerformed(ActionEvent e) {try{//disable OK 按钮...//做耗时的工作

    } finally{

    SwingUtilities.invokeLater(newRunnable(){

    @Overridepublic voidrun() {//enable OK 按钮...

    }});

    }

    }

    event dispatch thread的工作流程:

    enter handling code of event1 -> disable button -> ignore event2 -> enable button

    If invokeLater is called from the event dispatching thread -- for example, from a JButton's ActionListener -- the doRun.run() will still be deferred until all pending events have been processed.

    references:

    https://docs.oracle.com/javase/tutorial/uiswing/concurrency/

    https://docs.oracle.com/javase/7/docs/api/javax/swing/SwingUtilities.html#invokeLater(java.lang.Runnable)

    展开全文
  • 函数防抖与节流underscore.js提供了很多很有用的函数,今天想说说其中的两个。这两个函数都用于限制函数的执行debounce在解释这个函数前,我们先从一个例子看下这个函数的使用场景。假设我们网站有个搜索框,用户...

    函数防抖与节流

    underscore.js提供了很多很有用的函数,今天想说说其中的两个。这两个函数都用于限制函数的执行

    debounce

    在解释这个函数前,我们先从一个例子看下这个函数的使用场景。假设我们网站有个搜索框,用户输入文本我们会自动联想匹配出一些结果供用户选择。我们可能首先想到的做法就是监听keypress事件,然后异步去查询结果。这个方法本身是没错的,但是如果用户快速的输入了一连串的字符,假设是10个字符,那么就会在瞬间触发了10次的请求,这无疑不是我们想要的。我们想要的是用户停止输入的时候才去触发查询的请求,这时候函数防抖可以帮到我们。

    函数防抖就是让某个函数在上一次执行后,满足等待某个时间内不再触发此函数后再执行,而在这个等待时间内再次触发此函数,等待时间会重新计算。

    我们先看下underscore.js里相关函数的定义:

    _.debounce(function, wait, [immediate])

    // Returns a function, that, as long as it continues to be invoked, will not// be triggered. The function will be called after it stops being called for// N milliseconds. If `immediate` is passed, trigger the function on the// leading edge, instead of the trailing.

    _.debounce = function(func, wait, immediate) {

    var timeout, args, context, timestamp, result;

    var later = function() {

    var last = _.now() - timestamp;

    if (last < wait && last >= 0) {

    timeout = setTimeout(later, wait - last);

    } else {

    timeout = null;

    if (!immediate) {

    result = func.apply(context, args);

    if (!timeout) context = args = null;

    }

    }

    };

    return function() {

    context = this;

    args = arguments;

    timestamp = _.now();

    var callNow = immediate && !timeout;

    if (!timeout) timeout = setTimeout(later, wait);

    if (callNow) {

    result = func.apply(context, args);

    context = args = null;

    }

    return result;

    };

    };

    参数function是需要进行函数防抖的函数;参数wait则是需要等待的时间,单位为毫秒;immediate参数如果为true,则debounce函数会在调用时立刻执行一次function,而不需要等到wait这个时间后,例如防止点击提交按钮时的多次点击就可以使用这个参数。

    所以,上面那个场景,我们可以这么解决:

    function query() {

    //进行异步调用查询

    }

    var lazyQuery = _.debounce(query, 300);

    $('#search').keypress(lazyQuery);

    throttle

    我们网站经常会有这样的需求,就是滚动浏览器滚动条的时候,更新页面上的某些布局内容或者去调用后台的某接口查询内容。同样的,如果不对函数调用的频率加以限制的话,那么可能我们滚动一次滚动条就会产生N次的调用了。但是这次的情况跟上面的有所不同,我们不是要在每完成等待某个时间后去执行某函数,而是要每间隔某个时间去执行某函数,避免函数的过多执行,这个方式就叫函数节流。

    同样的,我们看下underscore.js里相关函数的定义:

    _.throttle(function, wait, [options])

    // Returns a function, that, when invoked, will only be triggered at most once// during a given window of time. Normally, the throttled function will run// as much as it can, without ever going more than once per `wait` duration;// but if you'd like to disable the execution on the leading edge, pass// `{leading: false}`. To disable execution on the trailing edge, ditto.

    _.throttle = function(func, wait, options) {

    var context, args, result;

    var timeout = null;

    var previous = 0;

    if (!options) options = {};

    var later = function() {

    previous = options.leading === false ? 0 : _.now();

    timeout = null;

    result = func.apply(context, args);

    if (!timeout) context = args = null;

    };

    return function() {

    var now = _.now();

    if (!previous && options.leading === false) previous = now;

    var remaining = wait - (now - previous);

    context = this;

    args = arguments;

    if (remaining <= 0 || remaining > wait) {

    if (timeout) {

    clearTimeout(timeout);

    timeout = null;

    }

    previous = now;

    result = func.apply(context, args);

    if (!timeout) context = args = null;

    } else if (!timeout && options.trailing !== false) {

    timeout = setTimeout(later, remaining);

    }

    return result;

    };

    };

    参数function是需要进行函数节流的函数;参数wait则是函数执行的时间间隔,单位是毫秒。option有两个选项,throttle第一次调用时默认会立刻执行一次function,如果传入{leading: false},则第一次调用时不执行function。{trailing: false}参数则表示禁止最后那一次延迟的调用。具体可以看源码进行理解。

    所以,在滚动滚动条的场景,我们可以这么做:

    function handleScroll() {

    //进行滚动时的相关处理

    }

    var throttled = _.throttle(handleScroll, 100);

    $(window).scroll(throttled);

    参考

    例子:

    restData:debounce( function (e) {

    this.topArr = [];

    this.resultList = [];

    this.pageNumber = 1;

    this.totalNum = 0; // 重置相关项

    this.searchData();

    }, this.INTERVAL),

    展开全文
  • 依赖//Rxjavaimplementation 'io.reactivex.rxjava2:rxjava:2.0.2'implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'implementation 'com.jakewharton.rxbinding2:rxbinding:2.0.0'Button bt = findViewById(R...

    依赖

    //Rxjava

    implementation 'io.reactivex.rxjava2:rxjava:2.0.2'

    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

    implementation 'com.jakewharton.rxbinding2:rxbinding:2.0.0'

    Button bt = findViewById(R.id.bt);

    RxView.clicks(bt)

    // 两秒之内点击多次只响应一次点击事件

    .throttleFirst(2, TimeUnit.SECONDS)

    .subscribe(new Observer() {

    @Override

    public void onSubscribe(Disposable d) {

    }

    @Override

    public void onNext(Object value) {

    Log.d(TAG, "发送了网络请求");

    }

    @Override

    public void onError(Throwable e) {

    Log.d(TAG, "对Error事件作出响应" + e.toString());

    // 获取异常错误信息

    }

    @Override

    public void onComplete() {

    Log.d(TAG, "对Complete事件作出响应");

    }

    });

    展开全文
  • java swing 防抖机制

    2019-10-03 00:20:44
    我们产品的 操作台(workbench) 是一个java swing程序.有一个event handler的代码如下: public void actionPerformed(ActionEvent e) { // 做耗时的工作, 如插入数据库 } 现在的一个问题在于, 如果用户连续...

    从问题开始说. 

    我们产品的 操作台(workbench) 是一个java swing程序. 有一个event handler的代码如下:

    public void actionPerformed(ActionEvent e) {
           // 做耗时的工作, 如插入数据库
    }

    现在的一个问题在于, 如果用户连续点了两次button, 则event handler被执行两次, 则用户会得到 主键重复错误.

    简单的想法是 在event handler的开头结尾把 对应的ok button给disable/enable.

    public void actionPerformed(ActionEvent e) {
      try {
        // disable OK 按钮...
           // 做耗时的工作
       } finally {
           // enable OK 按钮...
       }
    }

    但上面这段代码是错误的. 

    event dispatch thread的工作流程:  

        enter handling code of event1 -> disable button -> enable button -> enter handling code of event2

    正确的实现:

    public void actionPerformed(ActionEvent e) {
      try {
        // disable OK 按钮...
           // 做耗时的工作
        } finally {
               SwingUtilities.invokeLater(new Runnable(){
                   @Override
                   public void run() {
                       // enable OK 按钮...
               }});
        }
    }

    event dispatch thread的工作流程:  

         enter handling code of event1 -> disable button -> ignore event2 -> enable button

    If invokeLater is called from the event dispatching thread -- for example, from a JButton's ActionListener -- the doRun.run() will still be deferred until all pending events have been processed. 

    references:

    https://docs.oracle.com/javase/tutorial/uiswing/concurrency/

    https://docs.oracle.com/javase/7/docs/api/javax/swing/SwingUtilities.html#invokeLater(java.lang.Runnable)

    转载于:https://www.cnblogs.com/brayden/p/5227819.html

    展开全文
  • 1.使用场景:是在写keyup事件的时候,每次触发,都会请求后台接口,为了避免,每次请求,键盘弹起之后,隔上一段时间再去请求,所以用防抖函数2.概念:(1)什么是防抖:多次事件触发后、事件处理函数只执行一次,并且...
  • 节流和防抖这两个东西,你肯定听过,就是两种优化浏览器性能的手段。相关文章你肯定也看过,如果还是不太清楚,没关系,看完这篇短文,相信你能轻松理解其中差别。防抖(deounce)我们先说防抖吧,这里有个小笑话,看...
  • 歪式絮叨:原本打算只用一篇文章总结下防抖和节流的,但是写着写着发现挺有意思的。所以准备会分成 3-4 篇来写了,单独的防抖和节流的实现,然后在去分享一下知名库的源码。今天先跟歪马一起看看防抖的实现吧。其他...
  • 为防止用户在数据加载的时候接连点击按钮造成数据混乱,...实现1.首先引入RxJava2implementation "io.reactivex.rxjava2:rxjava:2.1.17"implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'2.创建一个接口,里面...
  • JAVA 操作防抖(非RxJava方案)

    千次阅读 2018-07-14 11:02:26
    JAVA 操作防抖,在手机网络状态变化时发生了重复调用,因此需要进行防抖。本打算用RxJava方案的,发现没必要那么麻烦,就找了个现成的类修改了下,发现确实还比较好用,代码如下。package com.xxx.xxx; import java...
  • 防抖是指在事件被触发 n 秒后再执行回调,如果在这 n 秒内事件又被触发,则重新计时。例如对于一个按钮,可以规定它在点击0.5s后再响应,若这0.5s内又被点击了,则重新计时,只要在0.5s内不再被点击就可以作出响应。...
  • 日期:2013-6-25来源:GBin1.com高频执行事件/方法的防抖通常,开发人员会在有用户交互参与的地方添加事件,而往往...这就是为什么我们要引入防抖防抖可以限制一个方法在一定时间内执行的次数。以下代码是个防抖...
  • 前言最近在家里上班有点闲,就刷了些前端面试题,研究一下函数节流和函数防抖。这东西在项目中也常用,但一直是直接从网上copy代码,没深究过,最近就仔细看了下,还是有点收获的,前端面试的时候,常会被问道闭包的...
  • java之awt防抖

    2016-03-30 19:52:28
    public void update(Graphics g){ //...尽管现在已经很少人使用AWT,用swing或者其他框架,偶尔写点小游戏还是需要的,哈哈,java还是没有c#那样擅长桌面程序。 将上述方法放在主类内即可。所谓的双缓冲!!!!!
  • 作者:git小米粥出自:CSDN一,防抖1、定义和原理定义:防抖,即如果短时间内大量触发同一事件,都会重置计时器,等到事件不触发了,再等待规定的事件,才会执行函数。(举个简单的例子,就是如果你在我这篇博文疯狂...
  • 概念防抖(debounce)当持续触发事件时,一定时间段内没有再触发事件,事件处理函数才会执行一次,如果设定时间到来之前,又触发了事件,就重新开始延时节流(throttle)当持续触发事件时,保证在一定时间内只调用一次...
  • 日常浏览网页中,在进行窗口的 resize、scroll ...debounce(防抖)和 throttle(节流)的方式来减少事件或接口的调用频率,同时又能实现预期效果防抖:将几次操作合并为一此操作进行。原理是维护一个计时器,规定在 de...
  • 作者:krryblog博客地址:https://ainyi.com/79日常浏览网页中,在进行窗口的 resize、...导致用户体验非常糟糕此时可以采用 debounce(防抖)和 throttle(节流)的方式来减少事件或接口的调用频率,同时又能实现预期效...
  • [Kotlin] 简单Timer防抖

    2020-05-06 11:47:55
    防抖 在用户输入时,如果用户输入的每个字符都进行一次网络请求等IO操作,无疑是一种巨大的浪费,我们可以优化为等用户暂停输入时,再进行操作。一般优化的方式将操作延迟一段时间再执行,如果用户又进行了输入,则...
  • 点击上方☝Java编程技术乐园,轻松关注!及时获取有趣有料的技术文章文章很好,耐心阅读,记得点赞和关注哦~前言最近有个朋友在面试过程中遇到一个问题:什么是防抖和节流?糟了,这可触碰到我的知识盲区了,好像听...
  • Js中的防抖与节流

    2020-12-26 21:00:00
    开发者(KaiFaX)面向全栈工程师的开发者专注于前端、Java/Python/Go/PHP的技术社区作者 |hateonion来源 |https://hateonion.me/po...
  • 提交时是使用防抖还是节流 JDK的java.util.concurrent.ThreadPoolExecutor允许您将任务提交到线程池,并使用BlockingQueue来保存提交的任务。 如果要提交的任务有数千个,请指定一个“绑定”队列(即最大容量的队列...
  • Python实战社群Java实战社群长按识别下方二维码,按需求添加扫码关注添加客服进Python社群▲扫码关注添加客服进Java社群▲作者丨highway来源丨iOS成长之路Throttl...
  • # 前端方案 1. 节流和防抖 2. 静态化页面 # 后端方案 1. 保证java接口的幂等性 2. 采用消息队列 3. 利用redis缓存
  • debounce 防抖 见于Android距离传感器处理 asyschronous 异步的
  • 在开发有时候会通过很多方式处理事件防抖效果,比如计时器,时间差,今天采用自定义RxJava操作符和时间差分别进行处理。传统处理方式:public abstract class OnMultiClickListener implements View.OnClickListener...
  • 作用debounce:防抖;only emit an item from an Observable if a particular time-span has passed without it emitting another item,当一个事件发送出来之后,在约定时间内没有再次发送这个事件,则发射这个事件...
  • 根据窗口变化,改变页面展示需求还是很常见(如图片自适应、echarts自适应问题),以在vue中的使用举例一、方法介绍方法一:使用window的onresize...{// 注册事件 -- 防抖window.onresize = () => {if (!this.bAnti...
  • 对象的深浅拷贝 对象的深拷贝与浅拷贝的区别: 浅拷贝:仅仅复制对象的引用, 而不是对象本身。 深拷贝:把复制的对象所引用的全部对象都复制一遍 浅拷贝的实现: var obj = { ... skill : "Java" } } /...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

java防抖

java 订阅