Queue-based task processing in Agentic AI

Introduction

Queue-based task processing helps organize and handle tasks one by one in order. It makes sure tasks don't get lost and are done step-by-step.

When you have many tasks to do and want to handle them one at a time.

When tasks come in at different times and you want to keep them in order.

When you want to avoid doing many tasks all at once to prevent confusion.

When you want to track which tasks are waiting and which are done.

When you want to share tasks between different parts of a program safely.

Syntax

Agentic AI

class TaskQueue:
    def __init__(self):
        self.queue = []  # List to hold tasks

    def add_task(self, task):
        self.queue.append(task)  # Add task to the end

    def process_task(self):
        if self.queue:
            task = self.queue.pop(0)  # Remove task from front
            return task
        else:
            return None

    def is_empty(self):
        return len(self.queue) == 0

    def size(self):
        return len(self.queue)

The queue uses a list to store tasks in order.

Adding a task puts it at the end; processing removes from the front.

Examples

Empty queue: no tasks yet.

Agentic AI

task_queue = TaskQueue()
print(task_queue.is_empty())  # True
print(task_queue.size())      # 0

Queue with one task added.

Agentic AI

task_queue = TaskQueue()
task_queue.add_task('Task 1')
print(task_queue.is_empty())  # False
print(task_queue.size())      # 1

Processing removes the first task added.

Agentic AI

task_queue = TaskQueue()
task_queue.add_task('Task 1')
task_queue.add_task('Task 2')
print(task_queue.process_task())  # 'Task 1'
print(task_queue.size())          # 1

Processing from empty queue returns None.

Agentic AI

task_queue = TaskQueue()
print(task_queue.process_task())  # None

Sample Model

This program creates a task queue, adds three tasks, then processes each task in order. It prints the number of tasks before and after processing.

Agentic AI

class TaskQueue:
    def __init__(self):
        self.queue = []

    def add_task(self, task):
        self.queue.append(task)

    def process_task(self):
        if self.queue:
            task = self.queue.pop(0)
            return task
        else:
            return None

    def is_empty(self):
        return len(self.queue) == 0

    def size(self):
        return len(self.queue)

# Create a queue
my_task_queue = TaskQueue()

# Add tasks
my_task_queue.add_task('Download data')
my_task_queue.add_task('Clean data')
my_task_queue.add_task('Train model')

print(f"Tasks in queue before processing: {my_task_queue.size()}")

# Process tasks one by one
while not my_task_queue.is_empty():
    current_task = my_task_queue.process_task()
    print(f"Processing: {current_task}")

print(f"Tasks in queue after processing: {my_task_queue.size()}")

Important Notes

Time complexity: Adding tasks is fast (O(1)), but processing tasks by removing from the front is slower (O(n)) because lists shift elements.

Space complexity: The queue uses space proportional to the number of tasks stored.

Common mistake: Removing tasks from the front of a list can be slow; for many tasks, consider using collections.deque for faster operations.

Use queue processing when task order matters and you want to handle tasks one at a time.

Summary

Queue-based task processing keeps tasks in order and handles them one by one.

Adding tasks puts them at the end; processing removes from the front.

This method helps organize work and avoid confusion when many tasks arrive.

Practice

1. What is the main purpose of queue-based task processing in agentic AI?

easy

A. To process all tasks simultaneously

B. To keep tasks in order and process them one by one

C. To randomly select tasks for processing

D. To delete tasks without processing

Solution

1. Step 1: Understand queue behavior

   A queue stores tasks in the order they arrive, so the first task added is the first processed.

2. Step 2: Identify the purpose in task processing

   This order ensures tasks are handled one by one without confusion or overlap.

3. Final Answer:

   To keep tasks in order and process them one by one -> Option B

4. Quick Check:

   Queue = ordered, one-by-one processing [OK]

Hint: Remember: queues process tasks FIFO (first in, first out) [OK]

Common Mistakes:

• Thinking tasks run all at once
• Assuming tasks are processed randomly
• Believing tasks get deleted without processing

2. Which of the following is the correct way to add a task to a queue in Python?

easy

A. queue.append(task)

B. queue.pop(task)

C. queue.remove(task)

D. queue.insert(0, task)

Solution

1. Step 1: Recall queue addition method

   In Python, adding to the end of a list (queue) uses append().

2. Step 2: Check other options

   pop() removes items, remove() deletes by value, insert(0, task) adds to front, not end.

3. Final Answer:

   queue.append(task) -> Option A

4. Quick Check:

   Adding task = append() [OK]

Hint: Add tasks with append() to keep queue order [OK]

Common Mistakes:

• Using pop() which removes tasks
• Using remove() which deletes by value
• Inserting at front breaks queue order

3. Given the Python code below, what will be printed?

tasks = []
tasks.append('task1')
tasks.append('task2')
processed = tasks.pop(0)
print(processed)

medium

A. task2

B. None

C. task1

D. IndexError

Solution

1. Step 1: Understand queue operations in code

   Tasks are added with append, so tasks = ['task1', 'task2'].

2. Step 2: Analyze pop(0) effect

   pop(0) removes and returns the first item, 'task1'.

3. Final Answer:

   task1 -> Option C

4. Quick Check:

   pop(0) returns first task [OK]

Hint: pop(0) removes first item in list [OK]

Common Mistakes:

• Thinking pop(0) removes last item
• Expecting an error from pop(0)
• Confusing pop() with pop(-1)

4. What is wrong with this queue processing code?

tasks = []
tasks.append('task1')
tasks.append('task2')
processed = tasks.pop()
print(processed)

medium

A. It removes the last task instead of the first

B. It causes an IndexError

C. It adds tasks incorrectly

D. It prints None

Solution

1. Step 1: Understand pop() without index

   pop() without argument removes the last item in the list.

2. Step 2: Compare with queue behavior

   Queue should remove the first task (pop(0)), so this removes tasks in wrong order.

3. Final Answer:

   It removes the last task instead of the first -> Option A

4. Quick Check:

   pop() removes last, not first [OK]

Hint: pop() removes last; use pop(0) for queue front [OK]

Common Mistakes:

• Assuming pop() removes first item
• Expecting an error from pop()
• Confusing append() with pop()

5. You want to process tasks in order but also prioritize urgent tasks immediately. Which queue-based approach fits best?

hard

A. Use a single queue and always pop from the front

B. Randomly pick tasks from the queue to process

C. Use a stack to process tasks last-in, first-out

D. Use two queues: one for urgent tasks processed first, then normal tasks

Solution

1. Step 1: Understand the need for prioritization

   Urgent tasks must be processed before normal tasks, so a single queue is not enough.

2. Step 2: Choose a structure supporting priority

   Two queues let urgent tasks be handled first, then normal tasks, preserving order within each.

3. Final Answer:

   Use two queues: one for urgent tasks processed first, then normal tasks -> Option D

4. Quick Check:

   Two queues = priority handling [OK]

Hint: Separate urgent and normal tasks in two queues [OK]

Common Mistakes:

• Using one queue loses priority order
• Using stack reverses task order
• Random picking breaks order and priority