Question

在我的应用程序中，我有以下可能长时间运行的类：

ScheduleLocalNotificationsOperation
UnScheduleLocalNotificationsOperation
SyncEventsToDeviceCalendarOperation
UnSyncEventsToDeviceCalendarOperation
SaveProductsToLocalStorageImpl

等等。

其中大多数是以这种方式构建的：

public interface Operation {
    void execute();
}

public class ScheduleLocalNotificationsOperation implements Operation {

    private MyApplication application;
    private List<LocalNotificationDescriptor> localNotifications;

    public ScheduleLocalNotificationsOperation (MyApplication application, List<LocalNotificationDescriptor> localNotifications) {
        this.application = application;
        this.localNotifications = localNotifications;
    }


    @Override
    public void execute() {
        // Do some stuff
    }

}

理想情况下，我想将我的Operation类设计为与并发无关，并且能够从外部对它们强加一些多线程策略，如下所示：

public class MainActivity extends Activity {

    public static ExecutorService executorService = Executors.newCachedThreadPool();


    @Override
    public void onCreate() {
        executorService.submit(new Runnable {
            @Override
            public void run() {
                new ScheduleLocalNotificationsOperation(application, createLocalNotificationsList()).execute();
            }

        });
    }

}

但是这样我每次调用这些类时都应该在每个客户端实现一些并发策略。

另一方面，我不想通过向它们添加并发性来中断这些操作中的纯逻辑，所以我的问题基本上是，从设计角度来看，如果有明确的定义，更好的方法是什么一个？

我可以创建一个将被任何客户端调用的OperationsRunner类，并使用多态性执行任何Operation并使该类成为唯一一个处理并发的类吗？

谁应该实现并发 - 客户端或服务器

0 个答案: