Swift में Rate Limiting: iOS और macOS के लिए अनुरोध आवृत्ति सीमा

Swift में Rate Limiting: iOS और macOS ऐप्स के लिए पूरी गाइड

Rate limiting (अनुरोध आवृत्ति सीमा) मोबाइल और डेस्कटॉप ऐप्स की स्थिरता के लिए एक महत्वपूर्ण तंत्र है। Swift (iOS/macOS) इकोसिस्टम में, यह दृष्टिकोण API कॉल, I/O ऑपरेशन या किसी भी दोहराए जाने वाले कार्यों की संख्या को प्रति यूनिट समय में नियंत्रित करने की अनुमति देता है। Rate limiting के बिना, आपका ऐप सर्वर द्वारा ब्लॉक किए जाने, बैटरी को अनंत रीट्राई पर खर्च करने या नेटवर्क पर अत्यधिक लोड बनाने का जोखिम उठाता है।

Swift में अनुरोध आवृत्ति सीमा क्यों ज़रूरी है?

• API सीमाओं से सुरक्षा — कई सर्वर (जैसे GitHub, Twitter, Stripe) प्रति मिनट/घंटे अनुरोधों की सख्त कोटा निर्धारित करते हैं।
• प्रदर्शन अनुकूलन — तेज़ स्क्रॉल या एनिमेशन के दौरान कॉल के "तूफान" को रोकना।
• डेटा और बैटरी बचत — विशेष रूप से मोबाइल उपकरणों के लिए महत्वपूर्ण।
• App Store नीतियों का पालन — अत्यधिक बैकग्राउंड अनुरोध ऐप को अस्वीकार करवा सकते हैं।

Swift में Rate Limiting लागू करने के मुख्य तरीके

तीन बुनियादी पैटर्न देखें जिन्हें बिना तीसरे पक्ष की लाइब्रेरी के लागू किया जा सकता है:

1. टोकन बकेट (Token Bucket)

क्लासिक एल्गोरिदम, जहां "टोकन" एक निश्चित दर से जोड़े जाते हैं। प्रत्येक अनुरोध एक टोकन का उपभोग करता है। यदि टोकन खत्म हो जाते हैं, तो अनुरोध अस्वीकार कर दिया जाता है।

import Foundation

final class TokenBucket {
    private let capacity: Int
    private var tokens: Int
    private let refillRate: Double // प्रति सेकंड टोकन
    private var lastRefill: Date
    private let queue = DispatchQueue(label: "token.bucket.queue")
    
    init(capacity: Int, refillRate: Double) {
        self.capacity = capacity
        self.tokens = capacity
        self.refillRate = refillRate
        self.lastRefill = Date()
    }
    
    func tryConsume() -> Bool {
        queue.sync {
            refill()
            if tokens > 0 {
                tokens -= 1
                return true
            }
            return false
        }
    }
    
    private func refill() {
        let now = Date()
        let elapsed = now.timeIntervalSince(lastRefill)
        let newTokens = Int(elapsed * refillRate)
        if newTokens > 0 {
            tokens = min(capacity, tokens + newTokens)
            lastRefill = now
        }
    }
}

// उपयोग का उदाहरण
let limiter = TokenBucket(capacity: 10, refillRate: 2.0) // 10 अनुरोध, प्रति सेकंड 2
if limiter.tryConsume() {
    print("✅ अनुरोध स्वीकृत")
} else {
    print("⛔️ सीमा पार, प्रतीक्षा करें")
}

2. स्लाइडिंग विंडो एल्गोरिदम (Sliding Window)

पिछले N सफल अनुरोधों के टाइमस्टैम्प को याद रखता है। यदि विंडो भर जाती है, तो नए कॉल को ब्लॉक करता है।

final class SlidingWindowLimiter {
    private let maxRequests: Int
    private let windowDuration: TimeInterval
    private var timestamps: [Date] = []
    private let queue = DispatchQueue(label: "sliding.window.queue")
    
    init(maxRequests: Int, windowDuration: TimeInterval = 60) {
        self.maxRequests = maxRequests
        self.windowDuration = windowDuration
    }
    
    func canProceed() -> Bool {
        queue.sync {
            let now = Date()
            // पुराने टाइमस्टैम्प हटाएं
            timestamps.removeAll { now.timeIntervalSince($0) > windowDuration }
            
            if timestamps.count < maxRequests {
                timestamps.append(now)
                return true
            }
            return false
        }
    }
}

// उदाहरण: 10 सेकंड में अधिकतम 5 अनुरोध
let windowLimiter = SlidingWindowLimiter(maxRequests: 5, windowDuration: 10)

3. DispatchQueue के साथ Throttling

कॉल के बीच जबरन देरी के लिए GCD के अंतर्निहित तंत्र का उपयोग करता है।

final class Throttler {
    private var workItem: DispatchWork