使用Objective-C和dispatch库实现并发素数计算

作者：zj | 来源：互联网 | 2024-12-28 08:44

本文介绍如何使用Objective-C结合dispatch库进行并发编程，以提高素数计数任务的效率。通过对比纯C代码与引入并发机制后的代码，展示dispatch库的强大功能。

### 纯C程序示例
首先，我们编写一个简单的C程序来计算指定范围内整数中素数的数量。

```cpp
#include
#include
#include
#include
#include

#define ULL unsigned long long

bool is_prime(ULL x) {
ULL j = sqrtl(x + 1);
if (x == 2) return true;
if (x <2 || x % 2 == 0) return false;
for (ULL i = 3; i <= j; i += 2) {
if (x % i == 0) return false;
}
return true;
}

ULL p_count(ULL start, ULL end) {
ULL count = 0;
for (ULL i = start; i <= end; i++) {
if (is_prime(i)) count++;
}
return count;
}

int main(int argc, char **argv) {
ULL start_x, end_x;

if (argc <= 1) {
printf("usage: %s [start_num] end_num\n", argv[0]);
return 1;
}

if (argc == 2) {
sscanf(argv[1], "%llu", &end_x);
if (end_x <0) {
printf("end_num %llu must not be negative!\n", end_x);
return 2;
}
start_x = 0;
}

if (argc == 3) {
sscanf(argv[1], "%llu", &start_x);
sscanf(argv[2], "%llu", &end_x);
if (start_x <0 || end_x <0) {
printf("start_num %llu or end_num %llu must not be negative!\n", start_x, end_x);
return 3;
}
if (start_x >= end_x) {
printf("start_num %llu must be less than end_num %llu\n", start_x, end_x);
return 4;
}
}

printf("Calculating primes from %llu to %llu\n", start_x, end_x);

clock_t begin = clock();
ULL count = p_count(start_x, end_x);
double stop = ((1.0 * (clock() - begin)) / CLOCKS_PER_SEC) * 1000.0;
printf("In range (%llu - %llu), prime count is %llu (took %f ms)\n", start_x, end_x, count, stop);

return 0;
}
```

### 引入dispatch机制
接下来，我们将上述代码转换为Objective-C，并使用dispatch库实现并发操作。

```objc
#import

#define ULL unsigned long long

struct range_t {
ULL start;
ULL end;
};
typedef struct range_t range_t;
typedef range_t *prange_t;

bool is_prime(ULL x) {
ULL j = sqrtl(x + 1);
if (x == 2) return true;
if (x <2 || x % 2 == 0) return false;
for (ULL i = 3; i <= j; i += 2) {
if (x % i == 0) return false;
}
return true;
}

ULL p_count(ULL start, ULL end) {
ULL count = 0;
for (ULL i = start; i <= end; i++) {
if (is_prime(i)) count++;
}
return count;
}

range_t get_range(int index) {
switch (index) {
case 0: return (range_t){1, 10000};
case 1: return (range_t){10001, 20000};
case 2: return (range_t){20001, 30000};
case 3: return (range_t){30001, 40000};
default: return (range_t){-1, -1};
}
}

static ULL g_count = 0;
static NSNumber *g_lock_count = nil;

void callback(void *context) {
prange_t pr = context;
NSLog(@"Range: (%llu - %llu)", pr->start, pr->end);
ULL count = p_count(pr->start, pr->end);
@synchronized(g_lock_count) {
g_count += count;
}
}

void function_way(void) {
g_lock_count = @1;
range_t range_ary[4] = {{1, 100000}, {100001, 200000}, {200001, 300000}, {300001, 400000}};
dispatch_queue_t queue = dispatch_queue_create("WorkBlocks", NULL);
dispatch_group_t group = dispatch_group_create();

for (int i = 0; i <4; i++) {
dispatch_group_async_f(group, queue, &range_ary[i], callback);
}

dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"Final count is %llu", g_count);
}

void apply_way(void) {
dispatch_queue_t queue = dispatch_queue_create("WorkBlocks", NULL);
ULL __block last_count = 0;
NSNumber *lock_count = @2;

dispatch_apply(4, queue, ^(size_t i) {
range_t r = get_range(i);
NSLog(@"IDX:%lu: Range is (%llu - %llu)", i, r.start, r.end);
ULL count = p_count(r.start, r.end);
@synchronized(lock_count) {
last_count += count;
}
});

NSLog(@"Final count is %llu", last_count);
}

void group_way(void) {
NSNumber *lock_index = @1;
NSNumber *lock_count = @2;
ULL __block last_count = 0;
int __block work_index = 0;
dispatch_queue_t queue = dispatch_queue_create("WorkBlocks", NULL);
dispatch_group_t group = dispatch_group_create();

dispatch_block_t task = ^() {
int index = work_index;
NSLog(@"My work index is %d", index);
@synchronized(lock_index) {
++work_index;
}
range_t r = get_range(index);
ULL count = p_count(r.start, r.end);
@synchronized(lock_count) {
last_count += count;
}
};

for (int i = 0; i <4; i++) {
dispatch_group_async(group, queue, task);
}

dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"Final count is %llu", last_count);
}

int main(void) {
@autoreleasepool {
// Choose one of the following methods
// group_way();
// apply_way();
function_way();
}
return 0;
}
```

### 并发方法总结
本文展示了三种不同的并发实现方式：

1. **group_way**：使用`dispatch_group_t`管理多个异步任务，并确保所有任务完成后继续执行。
2. **apply_way**：利用`dispatch_apply`函数并行处理固定数量的任务。
3. **function_way**：通过`dispatch_group_async_f`函数异步执行任务，并传递上下文参数。

每种方法都有其特点和适用场景，读者可以根据具体需求选择合适的方式。

推荐阅读

get
UNP 第9章：主机名与地址转换

本章探讨了用于在主机名和数值地址之间进行转换的函数，如gethostbyname和gethostbyaddr。此外，还介绍了getservbyname和getservbyport函数，用于在服务器名和端口号之间进行转换。 ... [详细]

蜡笔小新 2024-12-27 11:26:39
import
寻找满足特定条件的整数N的最大和(a+b)

本文探讨了如何在给定整数N的情况下，找到两个不同的整数a和b，使得它们的和最大，并且满足特定的数学条件。 ... [详细]

蜡笔小新 2024-12-26 19:26:18
get
Weight the Tree（树形dp）

题目Link题目学习link1题目学习link2题目学习link3%%%受益匪浅！－－－－－&# ... [详细]

蜡笔小新 2024-12-26 15:55:56
import
golang常用库：配置文件解析库/管理工具viper使用

golang常用库：配置文件解析库管理工具-viper使用-一、viper简介viper配置管理解析库，是由大神SteveFrancia开发，他在google领导着golang的 ... [详细]

蜡笔小新 2024-12-28 13:47:52
import
Java并发编程：LinkedBlockingQueue的实际应用

本文介绍了Java并发库中的阻塞队列（BlockingQueue）及其典型应用场景。通过具体实例，展示了如何利用LinkedBlockingQueue实现线程间高效、安全的数据传递，并结合线程池和原子类优化性能。 ... [详细]

蜡笔小新 2024-12-27 18:51:49
import
java编写的简易计算器

主要用了2个类来实现的，话不多说，直接看运行结果，然后在奉上源代码1.Index.javaimportjava.awt.Color;im ... [详细]

蜡笔小新 2024-12-27 18:18:10
get
USACO 2014 Jan - Moolympics区间记录优化算法

题目描述：给定n个半开区间[a, b)，要求使用两个互不重叠的记录器，求最多可以记录多少个区间。解决方案采用贪心算法，通过排序和遍历实现最优解。 ... [详细]

蜡笔小新 2024-12-27 18:14:31
get
使用 Azure Service Principal 和 Microsoft Graph API 获取 AAD 用户列表

本文介绍了一段通用代码示例，该代码不仅能够操作 Azure Active Directory (AAD)，还可以通过 Azure Service Principal 的授权访问和管理 Azure 订阅资源。Azure 的架构可以分为两个层级：AAD 和 Subscription。 ... [详细]

蜡笔小新 2024-12-27 16:07:12
get
Unity 客户端框架设计：UI管理系统的构建

本文详细介绍了如何构建一个高效的UI管理系统，集中处理UI页面的打开、关闭、层级管理和页面跳转等问题。通过UIManager统一管理外部切换逻辑，实现功能逻辑分散化和代码复用，支持多人协作开发。 ... [详细]

蜡笔小新 2024-12-27 10:28:40
get
Splay Tree 区间操作优化

本文详细介绍了使用Splay Tree进行区间操作的实现方法，包括插入、删除、修改、翻转和求和等操作。通过这些操作，可以高效地处理动态序列问题，并且代码实现具有一定的挑战性，有助于编程能力的提升。 ... [详细]

蜡笔小新 2024-12-26 18:47:12
get
VxWorks中的双向链表与环形缓冲应用

本文详细探讨了VxWorks操作系统中双向链表和环形缓冲区的实现原理及使用方法，通过具体示例代码加深理解。 ... [详细]

蜡笔小新 2024-12-26 13:26:16
int
火星商店问题：线段树分治与持久化Trie树的应用

本题涉及编号为1至n的火星商店，每个商店有一个永久商品价值v。操作包括每天在指定商店增加一个新商品，以及查询某段时间内某些商店中所有商品（含永久商品）与给定密码值的最大异或结果。通过线段树分治和持久化Trie树来高效解决此问题。 ... [详细]

蜡笔小新 2024-12-27 21:23:11
import
Java 类成员初始化顺序与数组创建

本文探讨了Java中类成员的初始化顺序、静态引入、可变参数以及finalize方法的应用。通过具体的代码示例，详细解释了这些概念及其在实际编程中的使用。 ... [详细]

蜡笔小新 2024-12-27 19:39:42
get
新浪笔试题

1:有如下一段程序：packagea.b.c;publicclassTest{privatestaticinti0;publicintgetNext(){return ... [详细]

蜡笔小新 2024-12-27 19:32:17
import
Python 的 10 个开发技巧！太实用了

1.如何在运行状态查看源代码？查看函数的源代码，我们通常会使用IDE来完成。比如在PyCharm中，你可以Ctrl+鼠标点击进入函数的源代码。那如果没有IDE呢？当我们想使用一个函 ... [详细]

蜡笔小新 2024-12-27 18:36:54

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章