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

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

推荐阅读

import
java编写的简易计算器

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

蜡笔小新 2024-12-27 18:18:10
import
分页插件3指定到某一页

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

蜡笔小新 2024-12-27 15:19:01
数组
UNP 第9章：主机名与地址转换

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

蜡笔小新 2024-12-27 11:26:39
数组
Weight the Tree（树形dp）

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

蜡笔小新 2024-12-26 15:55:56
buffer
VxWorks中的双向链表与环形缓冲应用

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

蜡笔小新 2024-12-26 13:26:16
buffer
Linux设备驱动程序：异步时间操作与调度机制

本文介绍了Linux内核中的几种异步延迟操作方法，包括内核定时器、tasklet机制和工作队列。这些机制允许在未来的某个时间点执行任务，而无需阻塞当前线程，从而提高系统的响应性和效率。 ... [详细]

蜡笔小新 2024-12-26 08:55:03
input
编写有趣的VBScript恶作剧脚本

本文将介绍如何编写一些有趣的VBScript脚本，这些脚本可以在朋友之间进行无害的恶作剧。通过简单的代码示例，帮助您了解VBScript的基本语法和功能。 ... [详细]

蜡笔小新 2024-12-28 09:46:23
range
导航栏样式练习：项目实例解析

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

蜡笔小新 2024-12-27 19:42:28
range
USACO 2014 Jan - Moolympics区间记录优化算法

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

蜡笔小新 2024-12-27 18:14:31
hash
Java面试题解析

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

蜡笔小新 2024-12-27 13:55:14
数组
C语言实现小写金额转换为大写金额

在金融和会计领域，准确无误地填写票据和结算凭证至关重要。这些文件不仅是支付结算和现金收付的重要依据，还直接关系到交易的安全性和准确性。本文介绍了一种使用C语言实现小写金额转换为大写金额的方法，确保数据的标准化和规范化。 ... [详细]

蜡笔小新 2024-12-27 12:39:06
range
扫描线三巨头 hdu1928hdu 1255 hdu 1542 [POJ 1151]

学习链接：http:blog.csdn.netlwt36articledetails48908031学习扫描线主要学习的是一种扫描的思想，后期可以求解很 ... [详细]

蜡笔小新 2024-12-26 20:04:36
range
长春大学软件工程：二叉排序树实验报告

本实验主要探讨了二叉排序树（BST）的基本操作，包括创建、查找和删除节点。通过具体实例和代码实现，详细介绍了如何使用递归和非递归方法进行关键字查找，并展示了删除特定节点后的树结构变化。 ... [详细]

蜡笔小新 2024-12-26 15:32:56
input
C语言链表动态创建：头插法与尾插法详解

本文详细介绍了C语言中链表的两种动态创建方法——头插法和尾插法，包括具体的实现代码和运行示例。通过这些内容，读者可以更好地理解和掌握链表的基本操作。 ... [详细]

蜡笔小新 2024-12-26 13:59:07
数组
Codeforces Round #566 (Div. 2) A~F个人题解

Dashboard-CodeforcesRound#566(Div.2)-CodeforcesA.FillingShapes题意：给你一个的表格，你 ... [详细]

蜡笔小新 2024-12-25 18:41:21

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

Tags | 热门标签

RankList | 热门文章