BlocksとGrand Central Dispatchの紹介です。

12. #include <stdio.h>
#include <Block.h>
int main (int argc, const char * argv[]) {
void (^add)(int, int) = ^(int i, int j) {
printf("%d", i + j);
};
return 0;
}

14. ^{
printf("Hello world!n");
}();

15. int (^add)(int, int) = ^int(int i, int j) {
return i + j;
};
printf("%dn", add(1, 1)); // 2

16. int (^add)(int, int) = ^int(int i, int j) {
return i + j;
};
printf("%dn", add(1, 1)); // 2

17. int (^add)(int, int) = ^int(int i, int j) {
return i + j;
};
printf("%dn", add(1, 1)); // 2

18. int (^add)(int, int) = ^int(int i, int j) {
return i + j;
};
printf("%dn", add(1, 1)); // 2

19. ^void(void) {
printf("Hello world!n");
}();
^{
printf("Hello world!n");
}();

20. int i = 100;
int (^add)(int) = ^(int j) {
return i + j;
};
printf("%d", add(1)); // 101
i = 200;
printf("%d", add(1)); // 101

21. __block int i = 0;
int (^f)(int) = ^(int j) {
i++;
return i + j;
};
for (int index = 0; index < 10; index++) {
printf("%d ", f(index));
} // 1 3 5 7 9 11 13 15 17 19

22. __block int i = 0;
int (^f)(int) = ^(int j) {
i++;
return i + j;
};
for (int index = 0; index < 10; index++) {
printf("%d ", f(index));
} // 1 3 5 7 9 11 13 15 17 19

23. __block int i = 0;
int (^f)(int) = ^(int j) {
i++;
return i + j;
};
for (int index = 0; index < 10; index++) {
printf("%d ", f(index));
} // 1 3 5 7 9 11 13 15 17 19

24. __block int i = 0;
int (^f)(int) = ^(int j) {
i++;
return i + j;
};
for (int index = 0; index < 10; index++) {
printf("%d ", f(index));
} // 1 3 5 7 9 11 13 15 17 19

25. __block int i = 100;
int (^add)(int) = ^(int j) {
return i + j;
};
printf("%d", add(1)); // 101
i = 200;
printf("%d", add(1)); // 201

26. __block void (^reverse)(int, int) = ^(int curt, int
max) {
if (curt < max) {
reverse(curt + 1, max);
}
printf("%d ", curt);
};
reverse(0, 10); // 10 9 8 7 6 5 4 3 2 1 0

27. __block void (^reverse)(int, int) = ^(int curt, int
max) {
if (curt < max) {
reverse(curt + 1, max);
}
printf("%d ", curt);
};
reverse(0, 10); // 10 9 8 7 6 5 4 3 2 1 0

28. __block void (^reverse)(int, int) = ^(int curt, int
max) {
if (curt < max) {
reverse(curt + 1, max);
}
printf("%d ", curt);
};
reverse(0, 10); // 10 9 8 7 6 5 4 3 2 1 0

29. int (^(^curried_add)(int))(int) = ^(int x) {
return Block_copy(^(int y) {
return x + y;
});
};
int (^add)(int) = curried_add(1);
printf("%dn", add(1)); // 2
Block_release(add);

30. int (^(^curried_add)(int))(int)...
typedef int (^IntBlock)(int);
IntBlock (^curried_add)(int)...

31. typedef int (^Block)(void);
Block counter() {
__block int i = 0;
return Block_copy(^{
i += 1;
return i;
});
}
int main (int argc, const char * argv[])
{
Block c = counter();
printf("%dn", c()); // 1
printf("%dn", c()); // 2
printf("%dn", c()); // 3
Block_release(c);
return 0;
}

39. #include <stdio.h>
#include <dispatch/dispatch.h>
int main (int argc, const char * argv[])
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
0), ^{
sleep(1);
printf("Hello world!n");
});
sleep(3);
return 0;
}

41. #include <stdio.h>
#include <dispatch/dispatch.h>
int main (int argc, const char * argv[])
{
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,
0), ^{
sleep(1);
printf("Hello world!n");
});
sleep(3);
return 0;
}

47. dispatch_queue_t mq = dispatch_get_main_queue();
dispatch_queue_t gqd = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t gqh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t gql = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t gqb = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_queue_t cq = dispatch_queue_create("com.example.ConcurrentDispatchQueue",
DISPATCH_QUEUE_CONCURRENT);
dispatch_release(cq);
dispatch_queue_t sq = dispatch_queue_create("com.example.SerialDispatchQueue", DISPATCH_QUEUE_SERIAL);
dispatch_release(sq);

49. dispatch_async(queue,
^{
hoge();
});

50. dispatch_sync(queue, ^{
hoge();
});

51. dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, queue, ^{
hoge();
});
dispatch_group_async(group, queue, ^{
piyo();
});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(group);

52. dispatch_queue_t queue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{hoge(1);});
dispatch_group_async(group, queue, ^{hoge(2);});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{printf("done");});
dispatch_release(group);

53. dispatch_time_t time =
dispatch_time(DISPATCH_TIME_NOW, 3.0 *
NSEC_PER_SEC);
dispatch_after(time, queue, ^{
hoge();
});

54. dispatch_queue_t queue =
dispatch_queue_create("com.example.ConcurrentQu
eue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{ 1});
dispatch_barrier_async(queue, ^{
hoge();
});
dispatch_async(queue, ^{ 3});

55. dispatch_apply(10, queue, ^(size_t index) {
hoge(index);
});

56. static dispatch_once_t pred;
dispatch_once(&pred, ^{
hoge();
});

58. dispatch_queue_t queue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
for (int i = 0; i < 1000; i++) {
dispatch_async(queue, ^{
hoge(i);
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
piyo();
dispatch_semaphore_signal(semaphore);
});
}
dispatch_release(semaphore);