• 과거의 프로그램은 명령어의 나열이였기 때문에 읽기가 어려웠다. 어디로 튈지도 모르고
  • 이후 구조화된 프로그래밍이 도입되면서 좀 더 읽기 쉬워졌다.
    • if-then 형태의 구문이 그 일종이다.
    • if 조건을 만족했을 때 실행되는 블록은 정적으로 스코핑된다. 즉, 내부에서 선언된 변수는 블록이 끝나면 해제된다.
    • 이를 통해서 변수의 생명주기를 잘 파악할 수 있게 되었다.
  • 구조화된 프로그램은 위에서부터 아래로 순차적으로 읽도록 해서 이해를 돕는다.
• 하지만 콜백 기반의 비동기 코드는 위에서부터 아래로 읽기가 안되기 때문에 이해가 어렵고, 스코프를 확인하기도 힘들다.
• 하지만 새로 생긴 async/await를 쓰면 이를 가능하게 만들어준다.

func fetchThumbnails(for ids: [String]) async throws [String: UIImage] {
	var thumbnails: [String: UIImage] = [:]

	for id in ids {
		let request = thumbnailURLRequest(for: id)
		let (data, response) = try await URLSession.shared.data(for: request)
		try validateResponse(response)
		guard let image = await UIImage(data: data)?.byPreparingThumbnail(ofSize: thumbSize) else {
			throw ThumbnailFailedError()
		}
		thumbnails[id] = image
	}
	return thumbnails
}

• 위에서는 이미지를 순차적으로 처리하고 있는데, 이상적이지 않다. 동시에 다운로드 받게 하려면 어떻게 해야할까? → Task를 이용하면 된다.

  • task는 새로운 비동기 컨텍스트를 제공한다.
  • Swift컴파일러가 동시성 버그를 막기 위해 task 사용을 점검한다.
  • async 함수를 호출하는 것 만으로는 새로운 task가 생성되지 않는다.

• Swift가 제공하는 task(유연성과 심플함 사이에서의 균형)

  • async let

    • 기존의 let은 선형적인 구조였다.
    • async let을 만나면, 새로운 child task가 생성되고, 거기서 돌아간다.
    • async 함수를 호출하면, 이를 호출한 task를 그대로 사용한다.
    • 이때 내부에서 child task를 생성하고 연결하면, 해당 task는 모든 child task가 끝나야만 task가 종료된다. → task단위로 라이프 타임을 관리하지 않아도 된다.
      • task는 함수의 child는 아니지만, 생명주기는 함수와 맞춰간다.
      • 만약 아래쪽에서 await하고 있는데, 위에서 에러나 캔슬등이 발생하면 아래는 자동으로 cancel된다.
      • cancel은 더이상 해당 데이터가 필요 없다고 통보만 할뿐, 실제로 취소를 하는 것은 아니다.
        • 일종의 상태 값이고, 어디서는 체크할 수 있다.
        • 그래서 모든 태스크를 만들때, 취소 기능을 지원하도록 만들어야 한다.
      • 특정 task를 cancel하면 그 자식 task도 다 cancel된다.

    // 위에서 이미지 가져오는 코드를 별도로 추출
    // async let으로 동시 실행
    func fetchOneThumbnail(withID id: String) async throws -> UIImage {
    	let imageReq = imageRequest(for: id), metadataReq = metadataRequest(for: id)
    	async let (data, _) = URLSession.shared.data(for: imageReq)
    	async let (metadata, _) = URLSession.shared.data(for: metadataReq)
    
    	guard
    		let size = parseSize(from: try await metadata),
    		let image = try await UIImage(data: data)?.byPreparingThumbnail(ofSize: size)
    	else {
    		throw ThumbnailFailedError()
    	}
    
    	return image
    }
    

    • 취소 기능 지원

    func fetchThumbnails(for ids: [String]) async throws -> [String: UIImage] {
    	var thumbnails: [String: UIImage] = [:]
    	for id in ids {
    		try Task.checkCancellation() // 취소 상태면 throw
    
    		if Task.isCancelled { break } // 취소면 true. 부분적인 결과만 받아볼 수도 있다는 점에서 유의해야 한다.
    		thumbnails[id] = try await fetchOneThumbnail(withID: id)
    	}
    }
    

    • Group Task
      • async let 은 몇개의 Task가 동시적으로 돌아가는지 정적으로 결정된다.
      • 반면 동적으로 이를 결정하기 위해서 Group Task를 사용한다.
      • 각 task는 독립적으로 동작한다.

    func fetchThumbnails(for ids: [String]) async throws -> [String: UIImage] {
    	var thumbnails: [String: UIImage] = [:]
    	try await withThrowingTaskGroup(of: Void.self) { group in
    		for id in ids {
    			group.async {
    				thumbnails[id] = try await fetchOneThumbnail(withID: id) // 여기서 에러가 난다.
    			}
    		}
    	}
    
    	return thumbnails
    }
    

    • 테스크가 제공하는 데이터 경합에 대한 안정성
      • Task는 생성시 @Sendable 클로저를 인자로 받는다.
      • mutable 변수를 캡쳐할 수 없다.
      • 값타입, 액터, 자기 스스로 싱크를 맞추고 있는 클래스만 캡쳐할 수 있다.
    • 그래서 위 코드를 안전하게 고치면 다음과 같다.
      • 에러가 던져지면 실행중이던 task들은 자동으로 cancel된다.
      • 하지만 에러가 안나면 cancel되지 않는다. cancel을 원하면 group의 cancelAll() 메소드를 호출해야 한다.

    func fetchThumbnails(for ids: [String]) async throws -> [String: UIImage] {
    	var thumbnails: [String: UIImage] = [:]
    	try await withThrowingTaskGroup(of: (String, UIImage).self) { group in
    		for id in ids {
    			group.async {
    				return (id, try await fetchOneThumbnail(withID: id))
    			}
    		}
    		for try await (id, thumbnail) in group {
    			thumbnails[id] = thumbnail
    		}
    	}
    
    	return thumbnails
    }
    

    • Unstructured Concurrency → 더 유연하지만, 해야할 될 것이 더 많다.

      • 왜 필요한가? → sturcturecd 모델이 맞지 않는 경우가 있기 때문

        • non-async 컨텍스트에서 실행되어야 할 때
        • 단일 스코프 이상으로 task가 진행되어야 할 때

      • 예시

        @MainActor
        class MyDelegate: UICollectionViewDelegate {
        	func collectionView(_ view: UICollectionView,
        											willDisplay cell: UICollectionViewCell,
        											forItemAt item: IndexPath) {
        	let ids = getThumbnailIDs(for: item)
        	let thumbnails = await fetchThumbnails(for: ids) // 'await' in a function that does not support concurrency
        	display(thumbnails, in: cell)
        }
        

      • 돌아가도록 수정하면 다음과 같다.

        @MainActor
        class MyDelegate: UICollectionViewDelegate {
        	func collectionView(_ view: UICollectionView,
        											willDisplay cell: UICollectionViewCell,
        											forItemAt item: IndexPath) {
        	let ids = getThumbnailIDs(for: item)
        	async {
        		let thumbnails = await fetchThumbnails(for: ids) // 'await' in a function that does not support concurrency
        		display(thumbnails, in: cell)
        	}
        }
        

      • unstructured tasks의 특징

        • 현재 context의 actor isolation과 priority를 그대로 가져옴
        • 지속시간이 스코프에 매이지 않는다. async메소드 내에서 실행할 필요도 없다.
        • 반드시 수동으로 취소하거나 await해야 한다.

        @MainActor
        class MyDelegate: UICollectionViewDelegate {
        	var thumbnailTasks: [IndexPath: Task.Handle<Void, Never>] = [:]
        
        	func collectionView(_ view: UICollectionView,
        											willDisplay cell: UICollectionViewCell,
        											forItemAt item: IndexPath) {
        	let ids = getThumbnailIDs(for: item)
        	thumbnailTasks[item] = async {
        		defer { thumbnailTasks[item] = nil }
        		let thumbnails = await fetchThumbnails(for: ids)
        		display(thumbnails, in: cell)
        	}
        
        	func collectionView(_ view: UICollectionView,
        											didEndDisplay cell: UICollectionViewCell,
        											forItemAt item: IndexPath) {
        		thumbnailTasks[item]?.cancel()
        	}
        }
        

  • Detached Context

    • unstructed task의 일종
    • 원본 context로 부터 아무것도 이어받지 않음
    • 대신 옵셔널한 매개변수로 우선순위나 다른 특성을 제공해 줄 수 있음
    • 내부적으로 또 다른 트리를 만들 수도 있다.

  @MainActor
  class MyDelegate: UICollectionViewDelegate {
  	var thumbnailTasks: [IndexPath: Task.Handle<Void, Never>] = [:]
  
  	func collectionView(_ view: UICollectionView,
  											willDisplay cell: UICollectionViewCell,
  											forItemAt item: IndexPath) {
  	let ids = getThumbnailIDs(for: item)
  	thumbnailTasks[item] = async {
  		defer { thumbnailTasks[item] = nil }
  		let thumbnails = await fetchThumbnails(for: ids)
  
  		asyncDetached(priority: .background) { 
  			withTaskGroup(of: Void.self) { g in
  				g.async { writeToLocalCache(thumbnails) }
  				g.async { log(thumbnails) }
  				g.async { ... }
  			}
  		}
  		display(thumbnails, in: cell)
  	}
  
  	func collectionView(_ view: UICollectionView,
  											didEndDisplay cell: UICollectionViewCell,
  											forItemAt item: IndexPath) {
  		thumbnailTasks[item]?.cancel()
  	}
  }
  

• 정리