멀티태스킹 동시 수행

멀티태스킹 동시 수행

문제: 데이터에 대한 권한 검사를 하는 작업이 있다면 1만 개, 10만 개 등이 있을 수 있습니다. 한 개의 작업만 써서 실행하는 데 시간이 많이 걸릴 수 있습니다. 이럴 때 여러 개의 작업으로 나누어 데이터를 여러 단락으로 나누어 동시에 진행하는 것을 고려할 수 있습니까?

코드는 다음과 같습니다.

public abstract class ParallelTask {
    private final static String TAG = "ParallelTask";

    public ParallelTask() {
    }


    public void preExecute(Object... args) {
    }

    public abstract void async1(); //    

    public void async2() {
    }

    public void async3() {
    }

    public void async4() {
    }

    public void async5() {
    }

    public void async6() {
    }

    public void async7() {
    }

    public void async8() {
    }

    public void onAllExecute() {
    }

    public void onUICompleted() { //               
    }

    private Observable uiObs;

    /**
     *       ，      UI  
     */
    final public void execute(Object...args) {
        preExecute(args);
        //   ，  UI  
        uiObs = Observable.just(null).subscribeOn(AndroidSchedulers.mainThread());
        List methods = getOverrideMethods();
        int size = methods.size();
        String[] ms = methods.toArray(new String[size]);
        getParallelObservable(ms)
                .observeOn(Schedulers.immediate())
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        onAllExecute();
                        executeOnUICompleted();
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "ParallelTask onError()", e);
                    }
                    @Override
                    public void onNext(String string) {
                    }
                });

    }

    /**
     *      UI    
     */
    private void executeOnUICompleted(){
        if(uiObs != null){
            uiObs.subscribe(new Action1() {
                @Override
                public void call(Object o) {
                    onUICompleted();
                }
            });
        }
        uiObs = null;
    }

    private Observable getParallelObservable(String[] methods) {
        return Observable.from(methods).flatMap(new Func1>() {
            @Override
            public Observable call(String s) {
                return Observable.just(s).subscribeOn(Schedulers.io()).map(new Func1() {
                    @Override
                    public String call(String s) {
                        if ("async1".equals(s)) {
                            async1();
                        } else if ("async2".equals(s)) {
                            async2();
                        } else if ("async3".equals(s)) {
                            async3();
                        } else if ("async4".equals(s)) {
                            async4();
                        } else if ("async5".equals(s)) {
                            async5();
                        } else if ("async6".equals(s)) {
                            async6();
                        } else if ("async7".equals(s)) {
                            async7();
                        } else if ("async8".equals(s)) {
                            async8();
                        }
                        return s;
                    }
                });
            }
        });
    }

    /**
     *         
     * @return
     */
    private List getOverrideMethods() {
        List overrideMethods = new ArrayList<>();
        Method[] bfs = getClass().getDeclaredMethods();
        Method[] afs = ParallelTask.class.getDeclaredMethods();
        for (Method bm : bfs) {
            for (Method am : afs) {
                if (bm.getName().equals(am.getName()) &&
                        bm.getReturnType().equals(am.getReturnType())) {
                    Class[] bc = bm.getParameterTypes();
                    Class[] ac = am.getParameterTypes();
                    if (bc.length == ac.length) {
                        boolean isEqual = true;
                        for (int i = 0; i < bc.length; i++) {
                            if (!bc[i].equals(ac[i])) {
                                isEqual = false;
                                break;
                            }
                        }
                        if (isEqual) {
                            String name = bm.getName();
                            overrideMethods.add(name);
                        }
                    }
                }
            }
        }
        return overrideMethods;
    }

}

ParallelTask 추상 클래스를 구현하여 8개의 작업을 동시에 수행할 수 있으며 사용자가 개수를 추가할 수 있습니다.사용자는 ParallelTask 클래스를 만들고 async1 방법을 실현하여 자신의 요구에 따라 다른 방법을 실현하면 된다.