Что такое Concurrency?

Chto takoe Concurrency v Swift

Concurrency (Konkurentnost') - eto sposobnost' vypolnjat' neskolko zadach s perekrytiem vo vremeni. Eto ne to zhe samoe, chto Parallelism - Concurrency mozhet byt' na odnom yadern, gde zadachi chereduyutsya, a Parallelism - eto istinnyi parallel na mnogoyadernykh sistem.

Raznica: Concurrency vs Parallelism

Concurrency (1 yadernyj CPU):
Task1: ####__####__####__
Task2: __####__####__####

Parallelism (2 yadernyj CPU):
Core1: Task1 ################
Core2: Task2 ################

Concurrency - eto planirovka, Parallelism - eto vypolnenie.

Do Swift 5.5 - Opasnye callback'i

// BAD - callback hell
fetchUser { user in
    fetchPosts(for: user) { posts in
        fetchComments(for: posts) { comments in
            updateUI(with: comments)
        }
    }
}

// PROBLEMY:
// 1. Pyramid of Doom
// 2. Tyazhelo chitat'
// 3. Error handling - noj
// 4. Memory leaks - self references

Swift 5.5+ - async/await

Apple predstavila structured concurrency - novyj paradigm:

// GOOD - sequencial, no ne blokiruem poток
async {
    let user = try await fetchUser()
    let posts = try await fetchPosts(for: user)
    let comments = try await fetchComments(for: posts)
    updateUI(with: comments)
}

Async Functions

func fetchData() async -> Data {
    let url = URL(string: "api.example.com/data")
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

// Ispol'zovanie
let data = try await fetchData()

Structured Concurrency - Task

Task - eto edinyca raboty v concurrent srede:

// SEQUENTIAL - odinim zа drugim
async {
    let user = try await fetchUser()
    let posts = try await fetchPosts(for: user)
}

// CONCURRENT - parallel'no
async {
    let userTask = Task { try await fetchUser() }
    let postsTask = Task { try await fetchPosts() }
    
    let user = try await userTask.value
    let posts = try await postsTask.value
}

// ASYNC LET - ehlegantnee
async {
    async let user = fetchUser()
    async let posts = fetchPosts()
    
    let u = try await user
    let p = try await posts
}

Task Groups - mnogo zadach

let results = try await withThrowingTaskGroup(of: Data.self) { group in
    for url in urls {
        group.addTask {
            let (data, _) = try await URLSession.shared.data(from: url)
            return data
        }
    }
    
    var results: [Data] = []
    for try await data in group {
        results.append(data)
    }
    return results
}

Actor - Safe Concurrency

Actor - tip, kторyj garantiruet thread-safety:

actor UserCache {
    private var cache: [Int: User] = [:]
    
    func get(_ id: Int) -> User? {
        cache[id]
    }
    
    func set(_ user: User) {
        cache[user.id] = user
    }
}

// Ispol'zovanie
let cacheActor = UserCache()
await cacheActor.set(user)
let cached = await cacheActor.get(user.id)

Nonisolated - break out of Actor

actor DataProcessor {
    nonisolated func logError(_ error: Error) {
        // Ne zelyayetsya na data, mozhet byt' vyzvan bez await
        print("Error: \(error)")
    }
    
    func process() async throws {
        do {
            try await doWork()
        } catch {
            nonisolated(unsafe) var shared = 0
            logError(error)
        }
    }
}

Sendable - kompiliator proverki

// SAFE - value types i immutable
struct User: Sendable {
    let id: Int
    let name: String
}

// UNSAFE - class s mutacijom
class MutableUser: Sendable {  // WARNING!
    var name: String
}

MainActor - UI Thread

@MainActor
func updateUI() {
    label.text = "Updated"
}

// Ili dlja class'a
@MainActor
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
    }
}

Prakticheskij primer

@MainActor
class FeedViewModel: ObservableObject {
    @Published var posts: [Post] = []
    
    func loadPosts() async {
        do {
            async let userPosts = fetchUserPosts()
            async let trending = fetchTrendingPosts()
            
            let (user, trend) = try await (userPosts, trending)
            self.posts = user + trend
        } catch {
            print("Error: \(error)")
        }
    }
}

Cancellation

let task = Task {
    try await longRunningTask()
}

Task {
    try await Task.sleep(nanoseconds: 1_000_000_000)
    task.cancel()
}

Preimushchestva Structured Concurrency

• Type-safe - compiler proverit ves kod
• Readable - sekvencionnyj stil
• Automatic cancellation - deti Tasks otmeny
• No callback hell - flat kod
• Memory safe - ehkonomit memory

Kogda ispol'zovat'

• Network requests - async URLSession
• File IO - async file operations
• Database - async database queries
• Parallel work - Task groups
• UI updates - MainActor

Concurrency v Swift - eto revolyuciya v sravnenii s callback'ami i GCD. Ehto bezopasnyj, chitaemyj, i efectivnyj sposob pismat' asinkhronnыj kod.