Polling in Software Systems

 

Polling in Software Systems

Polling is a technique where a system repeatedly checks for changes or new data at regular intervals. It is often used when event-driven notifications (e.g., WebSockets, SQL Server notifications) are not available or feasible.

1. Types of Polling

a) Regular Polling (Fixed Interval)

  • The system checks for updates at a fixed time interval (e.g., every 10 seconds).
  • Simple to implement but can cause unnecessary load if updates are infrequent.

🔹 Example:
A background service in .NET Core checking for new database records every minute.

public class PollingService : BackgroundService
{
    private readonly ILogger<PollingService> _logger;

    public PollingService(ILogger<PollingService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Checking for updates...");
            CheckForUpdates();  // Replace with actual data check logic
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }

    private void CheckForUpdates()
    {
        // Query the database or API to check for changes
        _logger.LogInformation("Polling database...");
    }
}

✅ Pros:

  • Simple to implement.
  • No external dependencies.

❌ Cons:

  • Wastes resources when there are no changes.
  • Database or API load increases with shorter intervals.

b) Adaptive Polling (Backoff Strategy)

  • Dynamically adjusts polling frequency based on system activity.
  • If no changes occur, polling slows down (e.g., from 5 sec → 10 sec → 30 sec).

🔹 Example:
If the last 5 polls detected no changes, increase the delay.

public class AdaptivePollingService : BackgroundService
{
    private readonly ILogger<AdaptivePollingService> _logger;
    private int _pollingInterval = 5000;  // Start with 5 seconds
    private int _missedUpdates = 0;

    public AdaptivePollingService(ILogger<AdaptivePollingService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            bool dataChanged = CheckForUpdates();

            if (dataChanged)
            {
                _pollingInterval = 5000;  // Reset to 5 seconds
                _missedUpdates = 0;
            }
            else
            {
                _missedUpdates++;
                if (_missedUpdates >= 5) _pollingInterval = Math.Min(_pollingInterval * 2, 60000); // Max 60 sec
            }

            await Task.Delay(_pollingInterval, stoppingToken);
        }
    }

    private bool CheckForUpdates()
    {
        // Simulate checking database for updates
        _logger.LogInformation("Checking for updates...");
        return new Random().Next(0, 10) < 2;  // Simulate a 20% chance of change
    }
}

✅ Pros:

  • Reduces unnecessary database queries.
  • Improves performance & efficiency.

❌ Cons:

  • Delayed responses if updates occur after a long backoff.
  • More complex than fixed interval polling.

c) Long Polling

  • The client sends a request to the server and waits until a change occurs.
  • If the server detects a change, it immediately responds.
  • If no change occurs within a timeout (e.g., 30 sec), the server responds empty, and the client retries.

🔹 Example:
Long polling to get real-time notifications from a REST API.

[HttpGet("long-polling")]
public async Task<IActionResult> LongPolling(CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        if (CheckForUpdates())  // If data changed, return response
            return Ok(new { message = "New data available!" });

        await Task.Delay(5000, cancellationToken);  // Wait before checking again
    }
    return NoContent();
}

✅ Pros:

  • Real-time updates without constant requests.
  • Reduces unnecessary polling when no updates exist.

❌ Cons:

  • Requires holding HTTP connections, which can be inefficient for large-scale applications.

2. Polling in Different Scenarios

3. Polling in .NET Core with Caching

🔹 Example: Polling SQL Server and caching the results in MemoryCache.

public class DatabasePollingService : BackgroundService
{
    private readonly IMemoryCache _cache;
    private readonly string _connectionString;
    private DateTime _lastUpdated = DateTime.MinValue;

    public DatabasePollingService(IMemoryCache cache, IConfiguration config)
    {
        _cache = cache;
        _connectionString = config.GetConnectionString("DefaultConnection");
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await RefreshCacheIfNeeded();
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }

    private async Task RefreshCacheIfNeeded()
    {
        using var connection = new SqlConnection(_connectionString);
        using var command = new SqlCommand("SELECT MAX(LastModified) FROM Products", connection);
        connection.Open();
        
        var lastModified = (DateTime?)await command.ExecuteScalarAsync();
        if (lastModified > _lastUpdated)
        {
            _lastUpdated = lastModified ?? DateTime.MinValue;
            _cache.Remove("ProductsCache");  // Clear cache
        }
    }
}

4. Polling vs Event-Driven Alternatives

5. When to Use Polling?

✔️ When event-driven options are not available.
✔️ When the data doesn’t change often (adaptive polling).
✔️ When you need simple implementation without extra dependencies.

❌ Avoid polling when real-time performance is required.
❌ Avoid polling when server load is a concern (use SQL Dependency or SignalR instead).

Conclusion

  • Fixed polling is simple but wastes resources.
  • Adaptive polling improves efficiency by dynamically adjusting the interval.
  • Long polling provides real-time-like behavior without excessive requests.
  • Consider event-driven solutions like SQL Dependency, WebSockets, or message queues for better performance.

Comments

Post a Comment

Popular posts from this blog

Maxpooling vs minpooling vs average pooling

Image
Pooling is performed in neural networks to reduce variance and computation complexity. Many times, beginners blindly use a pooling method without knowing the reason for using it. Here is a comparison of three basic pooling methods that are widely used. The three types of pooling operations are: Max pooling: The maximum pixel value of the batch is selected. Min pooling: The minimum pixel value of the batch is selected. Average pooling: The average value of all the pixels in the batch is selected. The batch here means a group of pixels of size equal to the filter size which is decided based on the size of the image. In the following example, a filter of 9x9 is chosen. The output of the pooling method varies with the varying value of the filter size. The operations are illustrated through the following figures. Average, Max and Min pooling of size 9x9 applied on an image We cannot say that a particular pooling method is better over others generally. The choice of pooling operation is made...
Read more

Understand the Softmax Function in Minutes

Image
Learning machine learning? Specifically trying out neural networks for deep learning? You likely have run into the  Softmax function, a wonderful  activation function  that turns numbers aka logits into probabilities that sum to one. Softmax function outputs a vector that represents the probability distributions of a list of potential outcomes.  It’s also a core element used in  deep learning   classification  tasks. We will help you understand the Softmax function in a beginner friendly manner by showing you exactly how it works — by coding your very own Softmax function in python. If you are implementing Softmax in Pytorch and you already know Pytorch well, scroll down to the Deep Dive section and grab the code. This article has gotten really popular: 5800+ claps. It is updated constantly. Latest update Jan 2020 added a TL;DR section for busy souls. Dec 2019 (Softmax with Numpy Scipy Pytorch functional. Visuals indicating the location of Softmax func...
Read more

Percentiles, Deciles, and Quartiles

Image
Percentiles Percentile: the value below which a percentage of data falls. Example: You are the fourth tallest person in a group of 20 80% of people are shorter than you: That means you are at the  80th percentile . If your height is 1.85m then "1.85m" is the 80th percentile height in that group. In Order Have the data  in order , so you know which values are above and below. To calculate percentiles of height: have the data in height order (sorted by height). To calculate percentiles of age: have the data in age order. And so on. Grouped Data When the data is grouped: Add up all percentages  below  the score, plus  half  the percentage  at  the score. Example: You Score a B! In the test 12% got D, 50% got C, 30% got B and 8% got A You got a B, so add up all the 12% that got D, all the 50% that got C, half of the 30% that got B, for a total percentile of 12% + 50% + 15% =  77% In other words you...
Read more