使用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`函数异步执行任务，并传递上下文参数。

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

推荐阅读

ip
分页插件3指定到某一页

前言--页数多了以后需要指定到某一页（只做了功能，样式没有细调）html ... [详细]

蜡笔小新 2024-12-27 15:19:01
runtime
Python 的 10 个开发技巧！太实用了

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

蜡笔小新 2024-12-27 18:36:54
text
java编写的简易计算器

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

蜡笔小新 2024-12-27 18:18:10
ip
Akka BackoffSupervisor的深入解析与实践

本文详细介绍了Akka中的BackoffSupervisor机制，探讨其在处理持久化失败和Actor重启时的应用。通过具体示例，展示了如何配置和使用BackoffSupervisor以实现更细粒度的异常处理。 ... [详细]

蜡笔小新 2024-12-27 15:04:09
ip
寻找满足特定条件的整数N的最大和(a+b)

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

蜡笔小新 2024-12-26 19:26:18
io
深入理解KMP算法中的next数组：北大OJ 2406题解

本文详细探讨了KMP算法中next数组的构建及其应用，重点分析了未改良和改良后的next数组在字符串匹配中的作用。通过具体实例和代码实现，帮助读者更好地理解KMP算法的核心原理。 ... [详细]

蜡笔小新 2024-12-28 11:30:01
text
技术分享：从动态网站提取站点密钥的解决方案

本文探讨了如何从动态网站中提取站点密钥，特别是针对验证码（reCAPTCHA）的处理方法。通过结合Selenium和requests库，提供了详细的代码示例和优化建议。 ... [详细]

蜡笔小新 2024-12-28 04:11:47
io
USACO 2014 Jan - Moolympics区间记录优化算法

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

蜡笔小新 2024-12-27 18:14:31
text
Python自动化处理：从Word文档提取内容并生成带水印的PDF

本文介绍如何利用Python实现从特定网站下载Word文档，去除水印并添加自定义水印，最终将文档转换为PDF格式。该方法适用于批量处理和自动化需求。 ... [详细]

蜡笔小新 2024-12-27 13:10:20
ip
UNP 第9章：主机名与地址转换

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

蜡笔小新 2024-12-27 11:26:39
text
C#中获取进程主窗口句柄的实现方法

本文介绍了如何在C#中启动一个应用程序，并通过枚举窗口来获取其主窗口句柄。当使用Process类启动程序时，我们通常只能获得进程的句柄，而主窗口句柄可能为0。因此，我们需要使用API函数和回调机制来准确获取主窗口句柄。 ... [详细]

蜡笔小新 2024-12-27 03:39:09
byte
深入理解Python的os和sys模块

本文详细解析了Python中的os和sys模块，介绍了它们的功能、常用方法及其在实际编程中的应用。 ... [详细]

蜡笔小新 2024-12-26 22:04:19
import
Objective-C 编程中的关键语法点

本文探讨了 Objective-C 中的一些重要语法特性，包括 goto 语句、块（block）的使用、访问修饰符以及属性管理等。通过实例代码和详细解释，帮助开发者更好地理解和应用这些特性。 ... [详细]

蜡笔小新 2024-12-26 19:42:38
import
Splay Tree 区间操作优化

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

蜡笔小新 2024-12-26 18:47:12
runtime
从 .NET 转 Java 的自学之路：IO 流基础篇

本文详细介绍了 Java 中的 IO 流，包括字节流和字符流的基本概念及其操作方式。探讨了如何处理不同类型的文件数据，并结合编码机制确保字符数据的正确读写。同时，文中还涵盖了装饰设计模式的应用，以及多种常见的 IO 操作实例。 ... [详细]

蜡笔小新 2024-12-26 17:37:25

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

Tags | 热门标签

RankList | 热门文章