Навыки swift-concurrency

⚡

swift-concurrency

Name: swift-concurrency
Author: AvdLee

Безопасно ⚙️ Внешние команды🌐 Доступ к сети

Implémenter des modèles de concurrence Swift

Swift Concurrency introduit async/await, les acteurs et la concurrence structurée. Cette compétence fournit des conseils d'experts pour adopter ces modèles en toute sécurité, éviter les conditions de concurrence et migrer les bases de code existantes vers Swift 6 avec la sécurité des threads au moment de la compilation.

Поддерживает: Claude Codex Code(CC)

🥉 72 Бронза

Скачать ZIP навыка

Загрузить в Claude

Перейдите в Settings → Capabilities → Skills → Upload skill

Включите и начните использовать

Протестировать

Использование «swift-concurrency». Convertir ma récupération d'API basée sur les closures vers async/await

Ожидаемый результат:

## Modèle async/await converti
• Paramètre du gestionnaire de complétion supprimé
• Mot-clé async ajouté à la fonction
• Utilisation de try await pour l'appel réseau
• Les erreurs se propagent automatiquement
• Gestion d'erreurs simplifiée avec do-catch

Использование «swift-concurrency». Rendre ma classe de cache thread-safe en utilisant un acteur

Ожидаемый результат:

## Sécurité des threads basée sur les acteurs
• Classe convertie en type acteur
• État mutable isolé dans l'acteur
• Synchronisation automatique lors de l'accès
• Sendable ajouté si passage à travers les frontières

Использование «swift-concurrency». Corriger les avertissements de conformité Sendable dans mon modèle

Ожидаемый результат:

## Options de conformité Sendable
• Les types valeur sont intrinsèquement Sendable
• Les classes peuvent se conformer avec @unchecked
• Documenter les invariants de sécurité pour @unchecked
• Considérer l'isolation de région pour les collections

Аудит безопасности

Безопасно

v5 • 1/16/2026

Pure documentation skill containing only markdown reference files. No executable code, no network calls, no file system access, no environment access, and no external commands. Provides safe educational guidance on Swift Concurrency patterns.

Просканировано файлов

6,603

Проанализировано строк

находки

Всего аудитов

Факторы риска

⚙️ Внешние команды (799)

🌐 Доступ к сети (103)

Проверено: claude Посмотреть историю аудитов →

Оценка качества

Архитектура

100

Сопровождаемость

Контент

Сообщество

100

Безопасность

Соответствие спецификации

Что вы можете построить

Adopter les modèles async/await

Migrer le code réseau basé sur les callbacks vers la syntaxe moderne async/await avec gestion d'erreurs appropriée

Implémenter la sécurité des threads

Utiliser les acteurs et les types Sendable pour protéger l'état mutable partagé et prévenir les conditions de concurrence

Migrer vers Swift 6

Naviguer la vérification stricte de la concurrence, activer l'adoption progressive et corriger les avertissements d'isolation

Попробуйте эти промпты

Conversion async de base

Convertir cet appel réseau basé sur un gestionnaire de complétion pour utiliser la syntaxe async/await : [coller le code basé sur les closures]

Implémentation d'acteur

Refactoriser cette classe avec état mutable partagé pour utiliser un acteur pour un accès thread-safe : [coller le code de la classe]

Conformité Sendable

Rendre cette structure ou classe conforme à Sendable et expliquer pourquoi il est ou non sûr de la transférer à travers les frontières d'isolation : [coller la définition du type]

Migration Swift 6

Aidez-moi à migrer ce code Swift 5 vers Swift 6. Corriger ces avertissements de concurrence : [coller le code avec les diagnostics]

Лучшие практики

Préférer la concurrence structurée avec les groupes de tâches plutôt que les tâches détachées pour l'annulation automatique
Utiliser les acteurs pour l'état mutable partagé au lieu des verrous ou des files d'attente de dispatch
Rendre les types Sendable lors du passage à travers les frontières d'isolation pour activer la sécurité au moment de la compilation
Compléter toutes les modifications d'état de l'acteur avant les points de suspension pour prévenir les bogues de réentrance

Избегать

Utiliser @MainActor comme correctif général sans justifier la nécessité du thread principal
Utiliser @unchecked Sendable pour faire taire les avertissements sans prouver la sécurité des threads
Conserver un travail de longue durée sur des acteurs qui provoque une contention inutile
Supposer que l'état est inchangé après await en raison de la réentrance de l'acteur

Часто задаваемые вопросы

Quelles versions de Swift prennent en charge les fonctionnalités de concurrence ?

Async/await nécessite Swift 5.5+. Les acteurs, groupes de tâches et AsyncSequence ont été livrés dans Swift 5.5. Swift 6 active la vérification stricte complète de la concurrence par défaut.

Quelles sont les principales limites de la concurrence ?

Les tâches ne peuvent pas dépasser le pool de threads disponible. Les acteurs sérialisent l'accès, ce qui peut causer de la contention. La création de tâches a un coût, évitez donc de générer des milliers de tâches pour un travail trivial.

Comment cela s'intègre-t-il avec le code existant ?

Utilisez Task {} pour faire le pont entre les contextes sync et async. Enveloppez les gestionnaires de complétion avec withCheckedContinuation. Adoptez progressivement la concurrence module par module.

Mes données sont-elles sûres lors de l'utilisation de cette compétence ?

Cette compétence fournit uniquement de la documentation de guidance. Aucune exécution de code, aucun accès aux données, aucun appel réseau. Tous les conseils sont des orientations en lecture seule.

Pourquoi vois-je des avertissements Sendable ?

Swift applique la sécurité des threads au moment de la compilation. Les types traversant les frontières d'isolation doivent être Sendable. Utilisez des types valeur, des acteurs, ou @unchecked Sendable uniquement avec une justification documentée.

Comment cela se compare-t-il à Combine ?

Swift Concurrency fournit du code async structuré et impératif. Combine utilise des flux réactifs. Pour les opérations async simples, async/await est plus simple. Combine excelle dans les transformations d'événements complexes.