DownloadQueue

The method fragment.RefreshButtons(); returns an NPE because if you implemented SectionsPagerAdapter like you should, getItem() returns a new Instance of that fragment which is not yet attached to the fragment manager, therefore causing a Nullpointer exception.

So what you should do is get a currently active fragment instance like this:

A suitable solution is KVO

First before the loop add the observer (assuming queue is the OperationQueue instance)

You can use Task.WaitAny()

Here is the demonstration of the behavior:

The only way to not block the removal listener (and thus break the cache) is to have a buffered channel. This means two changes:

1. Create the SendChannel with a non-zero capacity, see Channel(capacity) to consider the different behaviors. It mostly depends on what the behavior should be if more items expire than the consumer can handle.
2. Use SendChannel.offer() instead of SendChannel.sendBlocking(). If it returns false you can implement backup behavior like logging the failure so you can figure out what the best balance between memory and losing events is.

I think you have a problem with your call of the function. You cannot use your download queue in this case.

Instead of this, please use dispatch_main

Every call to QTimer::singleShot(...) is executed on the event loop of the thread where it is invoked **. If invoked from the main thread, it'll be the event loop started with app.exec().

According to the Qt-Network-Manager-Example, this function is called after the network-manager is filled with the URL's so the single-shot will be processed after the queue has been completely filled. Poorly the qt documentation isn't that clear about this topic yet, so for more information about event processing etc please look here.

Before I start, the timer is for having the download in an extra thread. So the GUI keeps responsive.

The complete downloadNext() method is recursive. It will be only called once and called till the queue is empty. See this:

The problem stems from the fact that iOS won't let you start a new task while the app is in the background. I believe that this is done to prevent apps from continuously firing off new tasks and keeping the app alive indefinitely.

Background tasks are generally suitable for gracefully handling your app transitioning from foreground to background while a task is in progress. It's the reason you're seeing the first task complete, but not the second.

One workaround would be to request background execution time from the OS when you fire off the initial data task:

Let's assume for a second that all those great classes in Java that handle synchronization do not exist, because this is a synthetic task, and all you got to handle is sychronized, wait and notify.

The first question to answer in simple words is: "Who is going to wait on what?"

• The download thread is going to wait for an URL to download.
• The caller is going to wait for the result of that download thread.

What does this mean in detail? We need at least one synchronization element between the caller and the download thread (your urlData), also there should be one data object handling the download data itself for convenience, and to check whether or not the download has yet been completed.

So the detailed steps that will happen are:

1. Caller requests new download.
   create: DownloadResult
   write: urlData(url -> DownloadResult)
   wake up 1 thread on urlData.

2. Thread X must find data to download and process it or/then fall asleep again.
   read: urlData (find first unprocessed DownloadResult, otherwise wait on urlData)
   write: DownloadResult (acquire it)
   write: DownloadResult (download result)
   notify: anyone waiting on DownloadResult
   repeat

3. Caller must be able to asynchronously check/wait for download result.
   read: urlData
   read: DownloadResult (wait on DownloadResult if required)

As there are reads and writes from different threads on those objects, synchronization is required when accessing the objects urlData or DownloadResult.

Also there will be a wait/notify association:

• caller -> urlData -> DownTh
• DownTh -> DownloadResult -> caller

After careful analysis the following code would fulfill the requirements:

Your computed property downloadQueue creates a an independend queue on each call. I.e. you are suspending the first created queue but the second and third queues are not influenced.

To fix it, create the queue only once, maybe in init()