“concurrent”的搜索结果

帮助应用迁移到Swift 6.2并设计并发代码，通过MainActor保护共享状态，解决数据竞争编译错误，梳理协议遵循，并将高负载计算显式移至后台执行。

• 将现有应用迁移到Swift 6.2
• 解决数据竞争编译错误
• 将高负载计算移至后台

Build concurrent Go applications with goroutines, lightweight execution units, and channels for communication. Apply patterns for worker pools, cancellation, synchronization, and orderly shutdown, and investigate race conditions when concurrent operations access shared data.

中文简介正在准备中。当前显示英语简介。

• Implement a worker pool for concurrent jobs
• Connect processing stages with channels
• Manage cancellation and orderly shutdown

Build Python applications that handle other work while waiting for network or database operations. Use asyncio and async/await to run tasks concurrently, manage errors and timeouts, and handle cancellation with appropriate cleanup.

中文简介正在准备中。当前显示英语简介。

• Building web APIs that handle many simultaneous requests
• Fetching data from multiple sources concurrently
• Implementing WebSocket servers and chat systems

Build Go services and command-line tools with clear interfaces, explicit error handling, and concurrent tasks using goroutines and channels. Use pprof to investigate performance, then check behavior with benchmarks, structured test cases, fuzzing, and race detection.

中文简介正在准备中。当前显示英语简介。

• Implementing concurrent tasks with cancellation and error handling
• Building gRPC or REST services and command-line tools
• Investigating Go performance with pprof and benchmarks

设计生产数据库的结构与数据迁移，涵盖列和索引变更、分批补全数据、分阶段替换列及恢复计划，帮助规划大表更新和不中断服务的结构切换。

• 为大表添加列或索引
• 分阶段更改列名以避免停机
• 分批补全现有数据

Measure performance in the agentic-flow worker system, including trigger detection, agent selection, caching, and concurrent operations. Run a full suite or individual benchmarks to compare response times and resource usage against configured targets.

中文简介正在准备中。当前显示英语简介。

• Checking overall worker system performance
• Measuring trigger detection and agent selection speed
• Examining cache behavior and memory usage

Reproduce timing and ordering bugs in a CTF sandbox using controlled concurrent requests. Compare normal and racing runs, trace reads and writes, and preserve a minimal sequence that demonstrates duplicate actions or inconsistent state.

中文简介正在准备中。当前显示英语简介。

• Reproduce bugs triggered by simultaneous requests
• Investigate duplicate actions and ineffective duplicate prevention
• Trace stale reads and gaps in locking

Build and debug asynchronous Rust applications with Tokio, a runtime for scheduling work while operations wait. Apply patterns for task management, channels, error handling, cancellation, and concurrency limits when developing network services and other concurrent systems.

中文简介正在准备中。当前显示英语简介。

• Build asynchronous network services
• Manage tasks and channel communication
• Design error handling and cancellation

Model distributed systems and concurrent algorithms in TLA+ or PlusCal, then check possible states with TLC. Use the results to investigate deadlocks, broken rules, and differences between specifications and implementation code.

中文简介正在准备中。当前显示英语简介。

• Model a distributed protocol before implementation
• Create a specification from existing concurrent code
• Investigate deadlocks and race conditions

Fix PostgreSQL deadlock errors caused by concurrent schema initialization in worker processes. Use when: (1) psycopg2.errors.DeadlockDetected during CREATE INDEX/TABLE IF NOT EXISTS, (2) Multiple Cloud Run jobs, Kubernetes pods, or worker processes start simultaneously, (3) Error shows "Process X waits for RowExclusiveLock... blocked by process Y", (4) init_schema() or migration code runs at worker startup. The key insight: "IF NOT EXISTS" is NOT truly concurrent-safe - PostgreSQL still acquires locks that can deadlock.

中文简介正在准备中。当前显示原文说明。

Organize a task into parallel work streams with clear dependencies, separate places for changes, and explicit checks. Batch independent reads and tests, coordinate concurrent work, and report completed or blocked tasks with verification results.

中文简介正在准备中。当前显示英语简介。

• Batching independent file reads and searches
• Splitting implementation across multiple agents
• Separating changes with Git worktrees

按Go语言惯例协助编写、审查和重构代码，整理错误处理、并发任务、接口与包结构，并检查内存使用，帮助形成便于阅读和维护的实现。

• 按Go惯例审查代码
• 改进现有代码的错误处理
• 设计支持取消的并发任务

Implement distributed data synchronization with CRDTs, data structures designed to merge concurrent updates. Covers counters, sets, shared values, and sequences, with incremental updates and tracking of dependencies between operations.

中文简介正在准备中。当前显示英语简介。

• Implementing shared counters across multiple nodes
• Merging concurrent additions and removals in shared sets
• Sending only changes during data synchronization

Take implementation work through small, independently mergeable pull requests. Use a separate working directory for each PR, record manual QA evidence, write English review descriptions, resolve CI and review findings, then merge and clean up.

中文简介正在准备中。当前显示英语简介。

• Deliver implementation work through pull requests
• Split a large task into small, independently mergeable PRs
• Build independent PRs concurrently

Design agents that respond to incoming emails, external notifications, and timers. Plan how they handle interruptions, prioritize new requests, track concurrent tasks, and deliver results while longer operations continue in the background.

中文简介正在准备中。当前显示英语简介。

• Connecting agents to incoming emails and external notifications
• Scheduling reports and recurring checks
• Handling interruptions and changes during long tasks

Build Python applications that keep other tasks moving while waiting for network, database, or file operations. Guides the choice of asyncio patterns, with timeouts, cancellation, error handling, and testing for asynchronous code.

中文简介正在准备中。当前显示英语简介。

• Build an asynchronous web API
• Fetch multiple web pages concurrently
• Develop a WebSocket server or chat system

Design storage for event sourcing, an approach that records changes as events. Compare database options and plan event ordering, duplicate handling, concurrent writes, and scaling to build a consistent event persistence layer.

中文简介正在准备中。当前显示英语简介。

• Compare event storage technologies
• Design event schemas and streams
• Handle concurrent and duplicate writes

Review C# asynchronous code and get suggestions for method names, return types, exception handling, concurrent tasks, and cancellation. Identify blocking calls and missing awaits, and choose patterns for long operations or sequences processed asynchronously.

中文简介正在准备中。当前显示英语简介。

• Reviewing async/await usage
• Finding blocking calls and missing awaits
• Planning concurrent tasks and cancellation

Analyze LLM serving traces to identify GPU time usage, opportunities to run operations concurrently, and known patterns for combining operations. Produce three consistent tables from saved traces or live captures on supported servers.

中文简介正在准备中。当前显示英语简介。

• Identify GPU operations that dominate inference time
• Compare input processing and token generation
• Trace GPU operations back to Python code

Build Python applications that keep other tasks moving while waiting for network, file, or database operations. The skill guides asyncio patterns, task cancellation, timeouts, workload limits, and testing for asynchronous APIs, scrapers, and background processing.

中文简介正在准备中。当前显示英语简介。

• Building asynchronous web APIs
• Sending concurrent requests in web scrapers
• Designing background tasks and queues

Write and review asynchronous C++ networking code using Boost.Asio or standalone Asio. The skill selects an implementation style for the installed library and C++ version, then checks memory lifetimes, concurrent writes, error handling, and build settings.

中文简介正在准备中。当前显示英语简介。

• Implementing asynchronous TCP or UDP servers and clients
• Reviewing buffer lifetimes and concurrent socket writes
• Adapting networking code to older Boost and C++ versions

Helps choose and tune Cloud Storage FUSE mounts, which expose bucket objects through file paths. It covers cache sizing, training performance, checkpoint write safety, and cost diagnosis on GKE, Compute Engine, and Cloud Run.

中文简介正在准备中。当前显示英语简介。

• Access training data through file paths
• Choose between FUSE, native reads, and shared file systems
• Check checkpoint and concurrent write safety

Run concurrent Omnigent conversations with real hosts and runners while replacing the LLM with a zero-latency mock. Read the generated report to explain response-time distributions, throughput, and failures, helping assess Omnigent's own processing overhead.

中文简介正在准备中。当前显示英语简介。

• Measuring performance with concurrent hosts
• Studying latency as conversation history grows
• Comparing throughput and failures under load

Compare batching, request scheduling, and memory management for a single model serving instance. Assess concurrent request capacity, response times, generation speed, and GPU time per result that meets the required quality and deadline.

中文简介正在准备中。当前显示英语简介。

• Comparing batching and request scheduling options
• Checking memory capacity for concurrent requests
• Assessing cache reuse and offloading tradeoffs