jdeferred库的使用

最新推荐文章于 2024-03-25 09:47:43 发布

吉凶以情迁

最新推荐文章于 2024-03-25 09:47:43 发布

阅读量351

点赞数

文章标签： thread 并发编程 java 多线程神经网络

本文链接：https://blog.csdn.net/u010042660/article/details/122188532

版权

如何使用和测试

apply plugin: 'java-library'

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    compile 'org.jdeferred.v2:jdeferred-core:2.0.0-beta2'
    compile 'org.slf4j:slf4j-simple:1.7.7'
//    compile 'org.jdeferred:jdeferred-android-aar:1.2.4'
}
//<groupId>org.slf4j</groupId>
//    <artifactId>slf4j-simple</artifactId>
//<version>1.7.7</version>
sourceCompatibility = "1.8"
targetCompatibility = "1.8"

关键方法

when() 子线程中执行可以添加多个回调。fail()失败的回调done()成功的回调always()成功和失败都会回调progress() 调用notify触发的回调filter()处理结果的拦截器，在主线程中执行,可以实现把一个结果强制改变。resolve 代表解决也就和done()回调挂钩reject 代表拒绝也就和fail回调挂钩

笔记

如果when多个里面有一个出错都会直接调用fail不会触发一次done

常用类

Deferred deferred = new DeferredObject();
这种object需要手动调用 resolve或者reject

举例

Promise promise = deferred.promise();
        promise.done(new DoneCallback() {
            @Override
            public void onDone(Object result) {
                System.out.println("done " + result + " " + Thread.currentThread().getName());
            }
        }).fail(new FailCallback() {
            @Override
            public void onFail(Object result) {

                System.out.println("fail    " + result + "  " + Thread.currentThread().getName());
            }
        }).progress(new ProgressCallback() {
            @Override
            public void onProgress(Object progress) {
                System.out.println("progress    " + progress + "    " + Thread.currentThread().getName());
            }
        }).always(new AlwaysCallback() {
            @Override
            public void onAlways(Promise.State state, Object resolved, Object rejected) {
                System.out.println("alayw   " + state.name() + " resoved:" + resolved + "   rejected:" + rejected + "   " + Thread.currentThread().getName());
            }
        });
        deferred.notify("1%");
        deferred.notify("10%");
        deferred.notify("100%"); //notify将调用 onProgress线程   调用3此，但是 不能在解决或者拒绝之后调用。
//        deferred.resolve("done_str");// done alay
        deferred.reject("333");

DeferredManager dm = new DefaultDeferredManager();
从作者github来看是用来配合when和then用的，
当when之后就调用then

DeferredManager dm = new DefaultDeferredManager();
        dm.when(new Callable<Integer>() { //子线程。
            public Integer call() {
                // return something
                // or throw a new exception
                System.out.println("when CALL thread:" + Thread.currentThread().getName());
                return 10;
            }
        }).then(new DoneCallback<Integer>() {
            @Override
            public void onDone(Integer result) {
                System.out.println("then result " + result + ",Thread:" + Thread.currentThread().getName());
            }
        }).done(new DoneCallback<Integer>() {
            public void onDone(Integer result) {
                System.out.println("onDone thread:" + Thread.currentThread().getName());
                System.out.println(" done. " + result);
            }
        }).fail(new FailCallback<Throwable>() {
            public void onFail(Throwable e) {
                System.out.println(" when fail. " + e.getMessage());
            }
        });

所有实例举例

System.out.println("exec " + Thread.currentThread().getName());
        Deferred deferred = new DeferredObject();
        Promise promise = deferred.promise();
        promise.done(new DoneCallback() {
            @Override
            public void onDone(Object result) {
                System.out.println("done " + result + " " + Thread.currentThread().getName());
            }
        }).fail(new FailCallback() {
            @Override
            public void onFail(Object result) {

                System.out.println("fail    " + result + "  " + Thread.currentThread().getName());
            }
        }).progress(new ProgressCallback() {
            @Override
            public void onProgress(Object progress) {
                System.out.println("progress    " + progress + "    " + Thread.currentThread().getName());
            }
        }).always(new AlwaysCallback() {
            @Override
            public void onAlways(Promise.State state, Object resolved, Object rejected) {
                System.out.println("alayw   " + state.name() + " resoved:" + resolved + "   rejected:" + rejected + "   " + Thread.currentThread().getName());
            }
        });
        deferred.notify("1%");
        deferred.notify("10%");
        deferred.notify("100%"); //notify将调用 onProgress线程   调用3此，但是 不能在解决或者拒绝之后调用。
        deferred.resolve("done_str");// done alay

        System.out.println("-=--------------------------");
        Deferred d = new DeferredObject();
        Promise p = d.promise();
        Promise filtered = p.filter(new DoneFilter<Integer, Integer>() {//处理成功结果
            public Integer filterDone(Integer result) {
                return result * 10;
            }
        });

        filtered.done(new DoneCallback<Integer>() {
            public void onDone(Integer result) {
                // result would be original * 10
                System.out.println("done result:" + result);
            }
        });
        d.notify(10);//毫无关系
        d.resolve(3);//发布的结果会被*10
        System.out.println("-=--------------------------");
//-------
        //如果小于100 正常，否则返回异常对象
        d = new DeferredObject();
        p = d.promise();

        p.pipe(new DonePipe<Integer, Integer, Exception, Void>() {
            public Deferred<Integer, Exception, Void> pipeDone(Integer result) {
                if (result < 100) {
                    return new DeferredObject<Integer, Exception, Void>().resolve(result);
                } else {
                    return new DeferredObject<Integer, Exception, Void>().reject(new RuntimeException());
                }
            }
        }).done(new DoneCallback() {
            @Override
            public void onDone(Object result) {
                System.out.println("done:" + result);
            }
        }).fail(new FailCallback() {
            @Override
            public void onFail(Object result) {

                System.out.println("fail:" + result);
            }
        });

//   d.resolve(15);//调用done回调
        d.resolve(150);//调用fail回调


        System.out.println("--------------------------");

        DeferredManager dm = new DefaultDeferredManager();
        dm.when(new Callable<Integer>() { //子线程。
            public Integer call() {
                // return something
                // or throw a new exception
                System.out.println("when CALL thread:" + Thread.currentThread().getName());
                return 10;
            }
        }).then(new DoneCallback<Integer>() {
            @Override
            public void onDone(Integer result) {
                System.out.println("then result " + result + ",Thread:" + Thread.currentThread().getName());
            }
        }).done(new DoneCallback<Integer>() {
            public void onDone(Integer result) {
                System.out.println("onDone thread:" + Thread.currentThread().getName());
                System.out.println(" done. " + result);
            }
        }).fail(new FailCallback<Throwable>() {
            public void onFail(Throwable e) {
                System.out.println(" when fail. " + e.getMessage());
            }
        });
        System.out.println("will exec over");


        System.out.println("-----------------");
        dm = new DefaultDeferredManager();
        dm.when(//传递2个参数
                () -> {
                    return "a";
                },
                () -> {
                    return "b";
                },
                () -> {
                    return "c";
                },
                () -> {
                    return "d";
                },
                () -> {
                    return "e";
                },
                () -> {
                    return "f";
                },
                () -> {
                    throw new RuntimeException("testfail");
                },
                () -> {
                    return "g";
                }
        ).progress(new ProgressCallback<MasterProgress>() {
            @Override
            public void onProgress(MasterProgress progress) {
                System.out.println("test progress");
            }
        }).done(rs ->//done会调用多次了
                rs.forEach(r -> System.out.println("->" + r.getResult()))
        ).fail(result -> {
            System.err.println("fail cail " + result);
        }).always((state, resolved, rejected) -> { //void onAlways(final State state, final D resolved, final F rejected); lambda中多个参数用括号包裹,
            //状态  解决 拒绝  不管是百还是成功都调用

            //成功则状态是解决失败状态是  拒绝。
            System.out.println("always: state:" + state.name());// 如果失败的时候获取参数 2 3 就会崩溃，"\nresolved:"+resolved.getSecond()+"\nrejected:"+resolved.getSecond()
        });
        //这个例子中，如果出现了一个失败，都不会走done,直接走 fail. when里面是运行在子线程的。

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("exec over");

执行结果: