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

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

推荐阅读

filter
Java并发编程：LinkedBlockingQueue的实际应用

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

蜡笔小新 2024-12-27 18:51:49
filter
Java 中 Writer flush()方法，示例

Java 中 Writer flush()方法，示例 ... [详细]

蜡笔小新 2024-12-28 06:41:52
window
导航栏样式练习：项目实例解析

本文详细介绍了如何创建一个具有动态效果的导航栏，包括HTML、CSS和JavaScript代码的实现，并附有详细的说明和效果图。 ... [详细]

蜡笔小新 2024-12-27 19:42:28
python
Python 的 10 个开发技巧！太实用了

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

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

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

蜡笔小新 2024-12-27 18:18:10
config
Dockerfile 编写与 Docker 网络配置详解

本文详细介绍了 Dockerfile 的编写方法及其在网络配置中的应用，涵盖基础指令、镜像构建与发布流程，并深入探讨了 Docker 的默认网络、容器互联及自定义网络的实现。 ... [详细]

蜡笔小新 2024-12-27 17:31:41
config
数据库内核开发入门 | 搭建研发环境的初步指南

本课程将带你从零开始，逐步掌握数据库内核开发的基础知识和实践技能，重点介绍如何搭建OceanBase的开发环境。 ... [详细]

蜡笔小新 2024-12-27 16:38:48
merge
Java面试题解析

本文详细介绍了Java编程语言中的核心概念和常见面试问题，包括集合类、数据结构、线程处理、Java虚拟机（JVM）、HTTP协议以及Git操作等方面的内容。通过深入分析每个主题，帮助读者更好地理解Java的关键特性和最佳实践。 ... [详细]

蜡笔小新 2024-12-27 13:55:14
merge
Spring Boot DevTools 实现项目自动重启功能

本文介绍了如何使用 Spring Boot DevTools 实现应用程序在开发过程中自动重启。这一特性显著提高了开发效率，特别是在集成开发环境（IDE）中工作时，能够提供快速的反馈循环。默认情况下，DevTools 会监控类路径上的文件变化，并根据需要触发应用重启。 ... [详细]

蜡笔小新 2024-12-28 04:42:15
merge
Java 中的 BigDecimal pow()方法，示例

Java 中的 BigDecimal pow()方法，示例 ... [详细]

蜡笔小新 2024-12-27 20:54:03
merge
Java 类成员初始化顺序与数组创建

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

蜡笔小新 2024-12-27 19:39:42
config
网络链路质量监控：Smokeping部署与配置

本文详细介绍了如何在Linux系统上安装和配置Smokeping，以实现对网络链路质量的实时监控。通过详细的步骤和必要的依赖包安装，确保用户能够顺利完成部署并优化其网络性能监控。 ... [详细]

蜡笔小新 2024-12-27 19:31:05
const
USACO 2014 Jan - Moolympics区间记录优化算法

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

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

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

蜡笔小新 2024-12-27 16:07:12
const
C++: 实现基于类的四面体体积计算

本文介绍如何使用C++编程语言，通过定义类和方法来计算由四个三维坐标点构成的四面体体积。文中详细解释了四面体体积的数学公式，并提供了两种不同的实现方式。 ... [详细]

蜡笔小新 2024-12-27 14:31:39

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

Tags | 热门标签

RankList | 热门文章