Question

Is there a way to do long processing loops in Python without freezing the GUI with TideSDK?
or I’ll just have to use threads…

Thanks.

Answer 1

There’s nothing really specific to TideSDK here—this is a general issue with any program built around an event loop, which means nearly all GUI apps and network servers, among other things.

There are three standard solutions:

1. Break the long task up into a bunch of small tasks, each of which schedules the next to get run.

2. Make the task call back to the event loop every so often.

3. Run the task in parallel.

For the first solution, most event-based frameworks have a method like doLater(func) or setTimeout(func, 0). If not, they have to at least have a way of posting a message to the event loop’s queue, and you can pretty easily build a doLater around that. This kind of API can be horrible to use in C-like languages, and a bit obnoxious in JS just because of the bizarre this/scoping rules, but in Python and most other dynamic languages it’s nearly painless.

Since TideSDK is built around a browser JS engine, it’s almost certainly going to provide this first solution.

The second solution really only makes sense for frameworks built around either cooperative threadlets or explicit coroutines. However, some traditional single-threaded frameworks like classic Mac (and, therefore, modern Win32 and a few cross-platform frameworks like wxWindows) use this for running background jobs.

The first problem is that you have to deal with re-entrancy carefully (at least wx has a SafeYield to help a little), or you can end up with many of the same kinds of problems as threads—or, worse, everything seems to work except that under heavy use you occasionally get a stack crash from infinite recursion. The other problem is that it only really works well when there’s only one heavy background task at a time, because it doesn’t work so well

If your framework has a way of doing this, it’ll have a function like yieldToOtherTasks or processNextEvent, and all you have to do is make sure to call that every once in a while. (However, if there’s also a doLater, you should consider that first.) If there is no such method, this solution is not appropriate to your framework.

The third solution is to spin off a task via threading.Thread or multiprocessing.Process.

The problem with this parallelism is that you have to come up with some way to signal safely, and to share data safely. Some event-loop frameworks have a thread-safe “doLater” or “postEvent” method, and if the only signal you need is “task finished” and the only data you need to share are the task startup params and return values, everything is easy. But once that’s not sufficient, things can get very complicated.

Also, if you have hundreds of long-running tasks to run, you probably don’t want a thread or process for each one. In fact, you probably want a fixed-size pool of threads or processes, and then you’ll have to break your tasks into small-enough subtasks so they don’t starve each other out, so in effect you’re doing all the work of solution #1 anyway.

However, there are cases where threads or processes are the simplest solution.