Queuing pictures to be requested in Django
Django itself doesn't have a queue, but you can easily simulate it. Personally, I would probably use an external service, like rabbitMQ, but it can be done in pure Django if you want. Add a separate ImageQueue model to hold references to incoming images and use transaction management to make sure simultaneous requests don't return the same image. Maybe something like this (this is purely proof of concept code, of course).

class ImageQueue(models.Model):
    image = models.OneToOne(Image)
    added = models.DateTimeField(auto_now_add=True)
    processed = models.DateTimeField(null=True, default=None)
    processed_by = models.ForeignKey(User, null=True, default=None)

    class Meta:
        order_by=('added')

...
# in the incoming image API that drone uses
def post_an_image(request):
    image = Image()
    ... whatever you do to post an image ...
    image.save()
    queue = ImageQueue.objects.create(image=image)
    ... whatever else you need to do ...

# in the API your users will use
from django.db import transaction

@transaction.atomic
def request_images(request):
    user = request.user
    num = request.POST['num'] # number of images requested
    queue_slice = ImageQueue.objects.filter(processed__isnull=True)[:num]
    for q in queue_slice:
        q.processed = datetime.datetime.now()
        q.processed_by = user
        q.save()
    return [q.image for q in queue_slice]
I am setting up a system where one user will be posting images to a Django server and N users will each be viewing a subset of the posted images in parallel. I can't seem to find a queuing mechanism in Django to accomplish this task. The closest thing is using latest with filter(), but that will just keep sending the latest image over and over again until a new one comes. The task queue doesn't help since this isn't a periodic task, it only occurs when a user asks for the next picture. I have one Viewset for uploading the images  and another for fetching. I thought about using the python thread-safe Queue. The unloader will enqueue the uploaded image pk, and when multiple users request a new image, the sending Viewset will dequeue an image pk and send it to the most recent user requesting an image and then the next one dequeued to the second most recent user and so on...
However, I still feel like there are some race conditions possible here. I read that Django is thread-safe, but that the app can become un-thread-safe. In addition, the Queue would need to be global to be shared among the Viewsets, which feels like bad practice. Is there a better and safer way of going about this?
Edit
Here is more detail on what I'm trying to accomplish and to give it some context. The user posting the pictures is a Smart-phone attached to a Drone. It will be posting pictures from the sky at a constant interval to the Django server. Since there will be a lot of pictures coming in. I would like to be able to have multiple users splitting up the workload of looking at all the pics (i.e. no two user's should see the same picture). So when a user will contact the Django server, saying "send me the next pic you have or send me the next 3 pics you have or etc...". However, multiple users might say this at the same time. So Django needs to keep some sort of ordering to the pictures,that's why I said Queue and figure out how to pass it to users if more than one of them asks at a time. So one Viewset is for the smart phone to post the pics and the other is for the users to ask for the pics. I am looking for a thread-safe way to do this. The only idea I have so far is to use Python's thread-safe queue and make it a global queue to the Viewsets. However, I feel like that is bad practice, and I'm not sure if it is thread-safe with Django.