문씨의 블로그

그외에도 Objective-C++을 빌드할때 걸리는 시간 차이도 있지만 여기서는 대략 넘어가겠습니다.

아무튼 이 LLVM덕분에 가능해진 기술이 Block과 GCD입니다.

* Block과 GCD는 iOS4.0부터 지원됩니다.

iOS4.0으로 업데이트 하면서 멀티테스킹이 지웠되었습니다.

덕분에 앱을 종료하지 않고 다른 앱에 갔다가 올수있게 되었습니다.

하지만 동시에 불편해진 부분도 있습니다.

바로 메모리 문제입니다. 여러앱이 동시에 실행되기 때문에 메모리 여유는 없을수밖에 없습니다. 그만큼 앱의 활동영역이 줄어들기 때문에 쾌적하지 못한 반응을 보여주기도 합니다.

하지만 애플은 이 문제에 대해 다른 안을 제시했습니다. GCD기술을 제공함으로써 메모리 부족의 문제를 로직적으로 개선된 성능으로 커버하도록 한겁니다. 어떤 의미로는 병주고 약주고라 할수있습니다.

그럼 GCD를 사용하려면 우선 Block코딩을 알아야 합니다.

Block코딩 없이는 GCD가 성립되지 않기 때문이죠.

WWDC10에서 세션113을 보면 Block에 대한 내용이 있습니다.

기존에 C를 하던분들은 알수도 있지만 보통 closure라고 부르는 코딩 기법입니다.

Objective-C에서는 Block이라고 부르는거죠.

위 슬라이드로 눈치챈 분도 있겠지만, 블럭은 간단히 말하면 코드를 객체화 할수 있다는 겁니다.

블럭은 우선 “ ^ ”로 시작합니다. ^ 블럭의 시작임을 알리는 구분자인것이죠.

먼저 C에서의 함수 구조를 볼까요?

int foo( int arg1, bool arg2) {

     ...

     return 0;

}

먼저 돌려주는 변수형이 있고 (없는경우 void) : int

함수명이 있습니다 : foo

그리고 ‘ ( ‘ 열고 ‘ )’ 닫으면서 파라메터(arguments)들이 들어가게 되죠. 

그리고 마지막으로 스코프 ‘ { ‘를 열고 내부에 코드를 넣은후 돌려줄 변수형이 있으면 return한후 스코프 ‘ } ‘를 닫습니다.

이것이 C함수의 기본이죠. *Objective-C가 아님

블럭에서는 단순히 이 구조에 함수명만 없는것입니다.

물론 앞에는 구분자(^)를 넣구요.

^ int (int arg1, bool arg2) {

     ....

   

      return 0;

}

그래서 가장 기본의 블럭 코딩의 형태는

^ <리턴변수형> ( <파라메터들> ) { ...<코드>... }

즉 돌려줄 변수타입, 파라메터, 본문 코드로 구성됩니다.

그리고 리턴 변수형과 파라메터는 없을경우 안 쓰고 무시 할수도 있습니다.

파라메터가 없는경우

^ int { ... } 

리턴이 없는경우

^ (int arg1) { ... }

둘다 없는경우

^ { ... }

물론 블럭 내부에 들어가는 코드는 Objective-C로 사용하면 됩니다.

블럭코딩의 응용기법은 많지만 너무 많은 관계로 가장 기본만 설명하겠습니다.

이부분은 애플도 강의를 포기한 부분입니다. 나머지는 알아서 공부해서 필요한걸 찾아 쓰라는 겁니다.

블럭코딩이 들어간 예를 하나 들겠습니다.

UIView에는 애니메이션 효과를 구현해주는 기능이 있습니다.

예를 들어 뷰를 이동시킨후 투명도를 조절해서 사라지게 하는 효과를 구현한다 치겠습니다.

view.center = CGPointMake(x, y);

[UIView beginAnimations:nil context:nil];

[UIView setAnimationDuration:2.0];

[UIView setAnimationDelegate:self];

[UIView setAnimationDidStopSelector:@selector(viewHide)];

view.center = CGPointMake(x2, y2);

[UIView commitAnimations];

먼저 해당 뷰를 이동시킵니다.

이동하는 애니메이션이 종료되면 viewHide라는 함수를 실행합니다.

그럼 그 함수에서

투명도설정으로 사라지도록 합니다.

- (void)viewHide {

[UIView beginAnimations:nil context:nil];

[UIView setAnimationDuration:2.0];

view.alpha = 0.0

[UIView commitAnimations];

}

이러식으로 애니메이션을 선언하고 재생 시간을 정해준후 설정하는 방법으로 은근히 코드가 길어집니다.

그리고 문제는 첫 애니메이션이 끝나면 viewHide라는 함수를 호출함으로써 다음 애니메이션을 호출하게 되는 점입니다. 함수라는 점과 조작하는 view가 계속 살아있는지 봐줘야 하는 부분도 문제입니다.

view가 전역이 아니라 처음 애니메이션을 실행하는 곳에서 사용되는 객체 변수라면  viewHide에서 사용하기 위해 전역으로 올리거나 beginAnimations함수에 인자로 객체를 같이 보내줄수도 있습니다.

이방법이나 저방법이나 번거롭기는 마찬가지죠

그래서 이번에 추가된 새로운 함수로 

+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations

가 있습니다.

간단하게 duration은 시간이고 animations에는 블럭코딩이 들어갑니다.

하지만 위에서 했던 것은 이중 애니메이션입니다. 

그럼 다른 함수로는

+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion

가 있습니다.

completion인자에 블럭 코딩을 하나더 받는걸로 애니메이션에 끝났을때 호출되도록 한것입니다.

코딩을 하다보면 줄이 너무 길어져서 줄넘겨본적이 있을겁니다.

인자가 너무 많아서 넘기기도 하고 배열같은건 아예 한줄한줄 넘기는것이 알아보기 쉽기도 합니다.

블럭코딩을 사용한 함수들은 자연스럽게 줄을 넘겨서 코딩 할수밖에 없게 됩니다.

앞서 했던 코딩을 블럭코딩 방식으로 구현해 보겠습니다.

view.center = CGPointMake(x, y);

[UIView animateWithDuration:2.0

 animations:^{

 view.center = CGPointMake(x2, y2);

 }

 completion:^(BOOL finished){

 [UIView animateWithDuration:2.0

  animations:^{

  view.alpha = 0.0;

  }];

 

 }];

어떤가요 이해가 가나요?

2초짜리 애니메이션을 animations에 넣고 작동 시키고 애니메이션이 끝나면 completion인자에 다른 블럭코딩을 넣어서 새로운 애니메이션을 실행했습니다.

블럭코딩의 특징은 함수내에서 선언된 객체도 유지된다는 겁니다.

시간차 때문에 코드가 실행되기 전에 객체가 해제되지 않을까 걱정할수도 있습니다만 그 코드 내부의 객체는 전부 retain올려서 관리됩니다.

블럭코딩을 받는 인자의 경우 API마다 받는 조건이 있습니다.

블럭코딩은 함수와 비슷한 구조라서 리턴이 있고 인자가 있습니다.

앞서 본 애니메이션 함수에 animations인자의 경우

(void (^)(void))animations

라고 선언되어 있습니다.

이경우 첫 단어는 void이므로 리턴할것이 없고, 

(^) 이후의 가로의 내용이 (void)이므로 인자도 없습니다.

그래서 animations인자에는  ^{ 으로 시작하면 되는겁니다

그리고 애니메이션 종료후 실행되는 블럭인 completion은 

(void (^)(BOOL finished))completion

라고 선언되어 있습니다.

리턴은 void이므로 당연히 없습니다 근데 이번에는 BOOL finished가 하나 있습니다

그러니 당연히 ^ (BOOL finished) { 로 만들어서 사용해야 합니다

이 finished인자는 애니메이션이 재생하다가 도중에 멈추는 경우를 비교하기 위한 겁니다. 재생 도중에 다른 곳에서 애니메이션 취소를 할수도 있기 때문이죠.

보통 YES입니다.

이제 블럭코딩에 대해 어느정도 이해했으면

본격적으로 GCD에 들어가보겠습니다.

GCD는 C언어로 되어있는 스레드 관리 기술입니다.

계층으로는 UIKit보다 하위로 

Application층과 UIKit층이 대부분 Objective-C를 사용하고 libSystem(예: SQLite)등이 C로 되어 있습니다.

커널층은.... 넘어가도록하죠.

즉 깊을 수록 어려워집니다.

GCD를 사용하려면 먼저 #include선언을 해주어야 합니다.

#include <dispatch/dispatch.h>

기왕이면 전역에 선언해 주고 사용하는게 편하겠죠.

먼저 블럭 코딩을 다룬것은 GCD는 블럭코딩을 이용했기 때문입니다.

• GCD는 Block-based API입니다.

멀티 스레딩 강좌 1탄 NSThread편과 2탄 NSOperation편에서 스레드의 기초와 스레드 응용기술을 다루어 보았습니다.

하지만 이 두 클래스의 스레드를 다루는 공통된 방식은 스레드용 함수를 만든다는 점입니다.

객체 지향방식인 Objective-C라서 이런 형태가 된것이지만 오히려 구현하기 힘들게 만드는 문제도 있습니다. 너무 객체지향을 추구하다보니 독이 된 셈이죠.

NSOperation덕에 스레드를 작업단위로 구분해서 할수 있게 되었지만 몇가지 간단한 작업을 위해서 클래스를 따로 만들어야 한다는 점은 여전히 불편합니다.

그에 비해 블럭코딩 기반의 GCD는 좀더 편히 코딩을 할수 있고 무엇보다 이미 해둔 코딩에 어느정도 쉽게 적용 가능하다는 장점이 있습니다.

멀티 스레딩 강좌로 원래 2편에 GCD를 할 예정이었습니다만, 개념 설명이 필요 하기 때문에 NSOperation을 다루었습니다.

큐 방식을 사용하는 NSOperation은 GCD와 비슷합니다.

WWDC에서 만난 애플 개발자에게서 GCD의 실체를 알고나서 물어본 질문은 Objective-C로 된것은 없는가? 였습니다.

답은 NSOperation이라고 합니다.

사실상 NSOperation은 GCD의 객체형이라고 볼수있다는 것이죠.

NSOperationQueue가 있듯이 GCD에는 dispatch_queue_t가 있습니다.

비교해 볼까요?

큐를 만드는 부분입니다.

NSOperationQueue *queue = [[[NSOperationQueue alloc] init] autorelease];

dispatch_queue_t dQueue = dispatch_queue_create(“com.apple.testQueue”, NULL);

NSOperationQueue의 경우 오토릴리즈가 걸려있어서 이후 일이 다 끝나면 알아서 해제 됩니다

하지만 C언어의 GCD는 생성했으면 해제를 해주어야 합니다

dispatch_release(dQueue);

물론 리테인 카운터 개념을 따르고 있기 때문에 dispatch_retain이라는 리테인 거는 함수도 있습니다.

GCD의 첫 함수 입니다. 

dispatch_queue_create

큐를 생성하는 함수이고 인자로는 char배열의 label과 attr이 있습니다.

label의 경우 큐에 이름을 지어주는 격으로 그다지 없어도 그만입니다. (NULL처리 해도 문제 없음)

attr경우 큐의 속성으로 설정하는 인자로 추정되지만 현재 API문서에는 안쓰고 있다고 합니다. 그냥 NULL

dispatch_queue_t는 변수 형으로 큐를 선언할때 사용됩니다.

이제 큐를 만들었으면 작업을 넣어보겠습니다.

NSOperationQueue의 경우 작업을 NSOperation으로 생성해서 넣었지만

GCD는 블럭을 작업 단위로 판단 합니다.

dispatch_async(dQueue, ^{

         ...

});

dispatch_async는 큐에 블럭을 넣는 일을 하는 함수입니다.

당연히 인자는 큐와 블럭을 받습니다.

다른 함수로 dispatch_sync도 있습니다.

이 두함수의 차이는 코드를 실행하는 동안 기다리는 유무입니다.

async의 경우 큐에 블럭을 넣는 일을 한후 바로 다음 코드로 넘어가지만

sync는 큐에 넣고 그 일이 끝날때까지 기다립니다.

기본 기능을 봤으니 이제 응용해보겠습니다.

멀티스레딩 NSOperation편에서 이미지를 다운 받아서 메인스레드에 영향을 안주고 이미지뷰에 띄우는 기능을 구현해 보았습니다.

이미지뷰에 카테고리로 함수를 만들고 내부에서 NSOperation으로 작업을 했었습니다.

순차적으로 본다면

우선 이미지뷰(UIImageView)를 준비하고

데이터를 다운받고

이미지로 로딩한다음

이미지뷰에 넣는것입니다.

이걸 코드로 구현해보겠습니다.

일단 이미지뷰는 화면에 이미 만들어져서 넣어져있다고 가정하고

UIImageView *imageView = ...

1. NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:@”주소”]];

2. UIImage *image = [UIImage imageWithData:data];

3. imageView.image = image;

1과 2는 다운받는 시간과 순간적 로딩하는 시간이 있기때문에 NSOperation에서는 이부분을 스레드로 돌린뒤 3번을 메인스레드로 돌아와서 지정하도록 했습니다.

근데 이미 코드가 상당합니다 아무리 간단해서 클래스를 만들고 지정하는 함수등 해야할 부분이 은근히 있습니다.

그런데 위 코드를 GCD에서는 어떻게 하는지 보겠습니다.

dispatch_async(dQueue, ^{

    

        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:@”주소”]];

        UIImage *image = [UIImage imageWithData:data];

        dispatch_sync(dispatch_get_main_queue(), ^{

                imageView.image = image;

        });

});

함수가 하나더 나왔군요 

dispatch_get_main_queue();

단어뜻 그대로 메인 스레드용 큐를 돌려주는 함수입니다.

즉 위의 코드는 먼저 전체 블럭을 dQueue에 넣습니다.

dQueue에서 실행되는 블럭은 다른 멀티 스레드로 돌아갑니다.

블럭이 스레드에서 실행되면서

먼저 데이터를 다운 받는 코드를 실행합니다.

그다음 이미지를 불러옵니다.

그리고 안에 구현된 두번째 블럭을 이번에는 메인큐(메인스레드)에 넣습니다.

이렇게 함으로서 화면에 관련된 코드는 메인스레드 상에서 돌렸습니다.

NSOperation으로 구현했을때와 사실상 같은 구조입니다.

다만 더 코드가 짧습니다.

NSOperation이나 NSThread를 사용하는 경우 NSAutoreleasePool을 사용해야 하지만

블럭코딩의 경우 필요가 없습니다.

NSOperationQueue의 경우 최대동시 작업 진행 설정이 있습니다.

기본값은 무한대라 큐에 작업을 넣는데로 바로 스레드가 생성됩니다.

물론 스레드가 너무 많아서는 안되기 때문에 보통 5개정도로 제한해둡니다.

하지만 GCD의 큐의 경우 무조건 한번에 하나만 실행됩니다.

큐에는 직접 만든 큐와 글로벌큐, 그리고 메인큐가 있습니다.

메인큐는 메인스레드상에서 돌리게 되어 있고

        dispatch_get_main_queue()

직접 만든 큐는 하나의 스레드를 할당 받고 사용합니다.

        dispatch_queue_create

글로벌 큐는 큐에 넣는대로 바로 스레드를 만들어서 붙여줍니다.

        dispatch_get_global_queue();

즉 NSOperationQueue에서 본다면 동시 실행 가능 작업수를 무한대로 하는것이 글로벌큐와 같은 역활이라고 보면 되고 직접만든 큐의 경우는 하나로 설정했다고 보면됩니다.

그렇다면 보통큐는 한 블럭이 끝나야 다음 블럭을 진행할수 있는데 어떻게 해야 동시 진행 구현할수 있을까요?

바로 글로벌 큐를 사용하는 방법입니다.

하지만 글로벌큐는 넣는 즉시 스레드로 만들기 때문에 반대로 제한을 줄수 없습니다.

그렇다면 만든큐에서 제한을 걸어서 글로벌큐에 필요한 수 만큼만 넣는겁니다.

카운트를 사용해서 루프 돌리며 기다리게 하는 방법은 그다지 추천하지 않습니다.

기다리는 동안 스레드를 돌리기 때문이죠.

 

일단 간단한 GCD예문을 만들어 보겠습니다.

변수 앞에 __block선언은 블럭들 안에 공통으로 사용하기 위한 선언입니다.

이렇게 하고 돌려보면

[Session started at 2010-08-17 00:49:44 +0900.]

2010-08-17 00:49:46.449 ThreadSample[21942:207] end

2010-08-17 00:49:46.449 ThreadSample[21942:1903] GCD: 0

2010-08-17 00:49:48.451 ThreadSample[21942:1903] GCD: 0 END

2010-08-17 00:49:48.452 ThreadSample[21942:1903] GCD: 1

2010-08-17 00:49:50.453 ThreadSample[21942:1903] GCD: 1 END

2010-08-17 00:49:50.454 ThreadSample[21942:1903] GCD: 2

2010-08-17 00:49:52.454 ThreadSample[21942:1903] GCD: 2 END

2010-08-17 00:49:52.455 ThreadSample[21942:1903] GCD: 3

2010-08-17 00:49:54.456 ThreadSample[21942:1903] GCD: 3 END

2010-08-17 00:49:54.457 ThreadSample[21942:1903] GCD: 4

2010-08-17 00:49:56.457 ThreadSample[21942:1903] GCD: 4 END

라고 뜹니다.

순차적으로 실행되긴하지만 결국 하나씩 진행되었습니다.

하지만 필요한건 동시 진행입니다.

여기서 등장하는것이 semaphore(시그널)입니다.

먼저 시그널또한 하나의 객체로 취급됩니다

dispatch_semaphore_t

큐를 만드는 법과 비슷하게 시그널을 만듭니다

dispatch_semaphore_t execSemaphore = dispatch_semaphore_create(5);

dispatch_semaphore_create함수는 시그널을 만들어 주는 함수입니다

인자로 갯수를 받습니다. 대충 5개로 하면 스레드를 5개까지만 한다고 보면됩니다.

이렇게 만들어진 시그널은 해제 할때 dispatch_release로 해제해주면됩니다.

이 시그널에 관련된 함수는 3개입니다.

생성용인 

dispatch_semaphore_create

신호를 날리는 

dispatch_semaphore_signal

그리고 신호를 받는 

dispatch_semaphore_wait

이 시그널의 작동원리는 이렇습니다

먼저 하나의 블럭이 실행되면

wait을 호출합니다. 

그러면 시그널은 내부 카운트를 1 올립니다.

그리고 내부 카운트가 먼저 생성할때 설정한 5보다 적으면 바로 돌아가고 많을 경우 스레드가 다음 코드로 넘어가지 못하게 Sleep을 걸어버립니다.

그리고 다른 블럭에서 작업이 끝날때 signal을 날려주면 내부 카운트가 하나 줄게됩니다.

내부 카운트가 줄었을때 설정한 5보다 적으면 재우던 스레드를 깨워서 진행 시켜주는 것이죠

먼저 기존의 블럭을 블럭을 실행할때 내부에서 글로벌큐에 새로운 블럭을 넣도록 이중구조로 변경합니다.

그리고 실행해보면 넣는 즉식 전부 글로벌 큐에 넣기 때문에 실행 순서를 알아보기 힘듭니다.

[Session started at 2010-08-17 01:23:02 +0900.]

2010-08-17 01:23:03.775 ThreadSample[22365:207] end

2010-08-17 01:23:03.776 ThreadSample[22365:1903] GCD: 0

2010-08-17 01:23:03.776 ThreadSample[22365:5d03] GCD: 1

2010-08-17 01:23:03.778 ThreadSample[22365:6203] GCD: 3

2010-08-17 01:23:03.777 ThreadSample[22365:6103] GCD: 2

2010-08-17 01:23:05.776 ThreadSample[22365:1903] GCD: 0 END

2010-08-17 01:23:05.777 ThreadSample[22365:5d03] GCD: 1 END

2010-08-17 01:23:05.779 ThreadSample[22365:6203] GCD: 3 END

2010-08-17 01:23:05.782 ThreadSample[22365:6103] GCD: 2 END

3초에 동시에 전부 실행되고 2초후인 5초에 전부 정지된것을 볼수있습니다.

이제 시그널을 사용해 보겠습니다.

코드가 길어보이는건 여러개를 돌려보기 위해서 그냥 코드를 복사한것뿐입니다.

돌려보면

[Session started at 2010-08-17 01:31:08 +0900.]

2010-08-17 01:31:09.172 ThreadSample[23337:207] end

2010-08-17 01:31:09.173 ThreadSample[23337:5e03] GCD: 0

2010-08-17 01:31:09.174 ThreadSample[23337:5f03] GCD: 1

2010-08-17 01:31:11.175 ThreadSample[23337:5e03] GCD: 0 END

2010-08-17 01:31:11.176 ThreadSample[23337:5e03] GCD: 2

2010-08-17 01:31:11.177 ThreadSample[23337:5f03] GCD: 1 END

2010-08-17 01:31:11.178 ThreadSample[23337:6503] GCD: 3

2010-08-17 01:31:13.176 ThreadSample[23337:5e03] GCD: 2 END

2010-08-17 01:31:13.177 ThreadSample[23337:5e03] GCD: 4

2010-08-17 01:31:13.179 ThreadSample[23337:6503] GCD: 3 END

2010-08-17 01:31:15.177 ThreadSample[23337:5e03] GCD: 4 END

이렇게 출력되었습니다.

시간기준으로 보면 0, 1이 동시에 진행하고 2, 3이 진행되었으며 4가 마지막으로 진행될걸 알수있습니다.

원하던 데로 두개씩 돌린겁니다.

그럼 작동 원리를 자세히 보겠습니다.