多线程 c语言改变线程优先级,线程安全

最新推荐文章于 2024-05-31 05:00:00 发布

weixin_39948111

最新推荐文章于 2024-05-31 05:00:00 发布

阅读量355

点赞数

文章标签：多线程 c语言改变线程优先级

多线程的存在导致在不同线程执行任务存在了数据、操作的不安全性，称之为非原子性。为了解决开发遇到的线程不安全的现象，就要用到线程锁。分别有 @synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock，不同的锁有不同的使用场景和性能上的区别。

@synchronized

@synchronized(objc) 为开发中常用的锁，他以一个 objc 为锁的标示对象，在需要互斥的代码之间，这个 objc 必须为同一对象，不然，将达不到互斥的效果。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

@synchronized(self){

NSLog(@"操作1开始");

sleep(3);

NSLog(@"操作1结束");

}

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

sleep(1);

@synchronized(self){

NSLog(@"操作2");

}

});

此段代码执行的结果为：

2018-08-15 15:14:48.387631+0800 Looks[4097:719747] 操作1开始

2018-08-15 15:14:51.391021+0800 Looks[4097:719747] 操作1结束

2018-08-15 15:14:51.391444+0800 Looks[4097:719750] 操作2

特点：简单易用，但性能最差。

dispatch_semaphore

GCD API 里面的信号量，也可以作为锁来使用，使用时搭配相关 API 使用。

dispatch_semaphore_t dispatch_semaphore_create(long value);

信号量的创建，value 为一个 long 类型的数，这里需要注意 value 应为非 0 的数，不然将起不到锁的效果。

long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

这个函数会对参数 dsema 的值加 1。

long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);

这个函数会对参数 dsema 的值减 1，该函数执行时当 dsema 的值大于0，不阻塞当前线程，执行后面操作，将 dsema 减1，当 dsema 等于 0 时，那么函数将会阻塞线程 timeout 时间，timeout 为 dispatch_time_t 类型，如果等待的期间 dsema 值被 dispatch_semaphore_signal 函数加了1，且获取到了信号量，那么线程将会执行大于0时的一样的操作，如果在等待且信号量没变且到了所设置的等待时间，那么将不再等待，执行后面操作。可设置 timeout 为 DISPATCH_TIME_FOREVER，这样将一直阻塞线程直到信号量改变。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));

NSLog(@"操作1开始");

sleep(3);

NSLog(@"操作1结束");

dispatch_semaphore_signal(semaphore);

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

sleep(1);

dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));

NSLog(@"操作2");

dispatch_semaphore_signal(semaphore);

});

以上代码 timeout > 2s 时，结果为：

2018-08-15 15:31:22.385087+0800 Looks[4411:738446] 操作1开始

2018-08-15 15:31:25.385388+0800 Looks[4411:738446] 操作1结束

2018-08-15 15:31:25.385653+0800 Looks[4411:738445] 操作2

如果 timeout < 2s 时，结果为：

2018-08-15 15:51:39.012859+0800 Looks[4632:759034] 操作1开始

2018-08-15 15:51:41.019446+0800 Looks[4632:759031] 操作2

2018-08-15 15:51:42.015130+0800 Looks[4632:759034] 操作1结束

特点：在不出现等待的情况下，性能最高。

NSLock

NSLock 也是我们经常用的一种锁。

- (void)lock;

- (void)unlock;

遵循了 NSLocking 协议，搭配的分别为锁和解锁。

- (BOOL)tryLock;

- (BOOL)lockBeforeDate:(NSDate *)limit;

tryLock：试图加锁并立即返回一个布尔值，该值指示尝试是否成功。如果返回 YES，加锁成功，反之失败。

lockBeforeDate：表示在指定时间之前加锁，如果到指定时间加锁成功，则返回 YES，加锁成功，反之失败。

NSLock *lock = [NSLock new];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

if ([lock tryLock]) {

NSLog(@"操作1开始");

sleep(3);

NSLog(@"操作1结束");

[lock unlock];

}

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

sleep(1);

if ([lock tryLock]) {

NSLog(@"操作2");

[lock unlock];

}else{

NSLog(@"tryLock 失败");

}

if ([lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:3]]) {

NSLog(@"lockBeforeData 获取到锁");

[lock unlock];

}else{

NSLog(@"lockBeforeData 超时,未获取到锁");

}

});

以上代码执行结果为：

2018-08-15 16:44:03.240428+0800 Looks[5079:796065] 操作1开始

2018-08-15 16:44:04.241003+0800 Looks[5079:796066] tryLock 失败

2018-08-15 16:44:06.241563+0800 Looks[5079:796065] 操作1结束

2018-08-15 16:44:06.242126+0800 Looks[5079:796066] lockBeforeData 获取到锁

特点：方便简单易用。

NSRecursiveLock (递归锁)

NSRecursiveLock 是常用在处理递归循环操作上的锁，所以叫递归锁。他可以处理同一个线程多次加锁，解锁而不会引起死锁。同样遵循 NSLocking 协议，API 和用法都和 NSLock 相同，不同的只有使用场景。

NSRecursiveLock *recursiveLock = [NSRecursiveLock new];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

static void (^ RecursiveLock)(int);

RecursiveLock = ^ (int value){

[recursiveLock lock];

if (value > 0) {

NSLog(@"value is %d",value);

sleep(1);

value -= 1;

RecursiveLock(value);

}

[recursiveLock unlock];

};

RecursiveLock(4);

});

以上代码执行 lock 和 unlock 一一对应，在统一线程中递归加锁解锁，这就是 NSRecursiveLock 的使用场景，执行结果为：

2018-08-16 13:57:30.195998+0800 Looks[3695:302951] value is 4

2018-08-16 13:57:31.197983+0800 Looks[3695:302951] value is 3

2018-08-16 13:57:32.201241+0800 Looks[3695:302951] value is 2

2018-08-16 13:57:33.205673+0800 Looks[3695:302951] value is 1

特点：对同一线程多次加锁、解锁。递归循环条件下适用。

NSConditionLock (条件锁)

这种锁不仅具备了 lock 和 unlock 功能，还有在 lock 和 unlock 的条件操作功能，这也丰富了我们使用的选择和场景。

- (void)lockWhenCondition:(NSInteger)condition;

- (BOOL)tryLock;

- (BOOL)tryLockWhenCondition:(NSInteger)condition;

- (void)unlockWithCondition:(NSInteger)condition;

- (BOOL)lockBeforeDate:(NSDate *)limit;

- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

和之前几个锁的 API 大同小异，唯一不同的就是多了一个参数 condition，这个参数就是我们要说的 lock 和 unlock 的条件，当 lock 时 condition 的参数和初始化参数一致时，将不阻塞线程，进行加锁继续后续操作，反之，将阻塞线程。而 unlock 时，condition 则是将更改为实参的值，解锁完成操作或者为下一次个 lock 的 condition 做准备。

NSConditionLock *conditionLock = [NSConditionLock new];

NSMutableArray *array = [NSMutableArray new];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

while (YES) {

[conditionLock lockWhenCondition:0];

[array addObject:[NSString stringWithFormat:@"%d", arc4random() % 10]];

NSLog(@"arry count is %lu",(unsigned long)array.count);

[conditionLock unlockWithCondition:1];

sleep(1);

}

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

while (YES) {

NSLog(@"condition 不相同, wait....");

[conditionLock lockWhenCondition:1];

[array removeObjectAtIndex:0];

NSLog(@"arry remove object at index for zero");

[conditionLock unlockWithCondition:0];

sleep(1);

}

});

以上代码执行结果为：

2018-08-16 14:19:09.390035+0800 Looks[4082:324058] arry count is 1

2018-08-16 14:19:09.390044+0800 Looks[4082:324059] condition 不相同, wait....

2018-08-16 14:19:09.390216+0800 Looks[4082:324059] arry remove object at index for zero

2018-08-16 14:19:10.391602+0800 Looks[4082:324059] condition 不相同, wait....

2018-08-16 14:19:10.391551+0800 Looks[4082:324058] arry count is 1

2018-08-16 14:19:10.391967+0800 Looks[4082:324059] arry remove object at index for zero

特点：当有加锁解锁条件时适用。

NSCondition

也是经常用且简单的一种锁，同样遵循 NSLocking 协议，实现了 lock 和 unlock 方法。

- (void)wait;

- (BOOL)waitUntilDate:(NSDate *)limit;

- (void)signal;

- (void)broadcast;

wait：阻塞当前线程，让线程处于等待状态，直到有线程信号，在调用此方法时，锁必须是 lock 状态。

waitUntilDate：阻塞当前线程，让线程处于等待状态直到条件发出信号或达到指定的时间限制。在调用此方法时，锁必须是 lock 状态。

signal：信号条件，唤醒一个等待线程。可以使用此方法唤醒正在等待条件的一个线程。可以多次调用此方法以唤醒多个线程。如果没有线程在等待条件，这个方法什么也不做。

broadcast：信号条件，唤醒所有等待它的线程。如果没有线程在等待条件，这个方法什么也不做。

NSCondition *codition = [NSCondition new];

NSMutableArray *array = [NSMutableArray new];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

while (YES) {

[codition lock];

if (array.count == 0 ) {

NSLog(@"wait ....");

[codition wait];

}

[array removeObjectAtIndex:0];

NSLog(@"array remove object index for zero");

[codition unlock];

}

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

while (YES) {

[codition lock];

[array addObject:[NSString stringWithFormat:@"%d",arc4random() % 10]];

NSLog(@"array count is %lu",(unsigned long)array.count);

[codition signal];

[codition unlock];

sleep(1);

}

});

以上代码执行的结果为：

2018-08-16 15:26:09.625351+0800 Looks[5145:383490] wait ....

2018-08-16 15:26:09.625543+0800 Looks[5145:383492] array count is 1

2018-08-16 15:26:09.625729+0800 Looks[5145:383490] array remove object index for zero

2018-08-16 15:26:09.626445+0800 Looks[5145:383490] wait ....

2018-08-16 15:26:10.629679+0800 Looks[5145:383492] array count is 1

2018-08-16 15:26:10.630167+0800 Looks[5145:383490] array remove object index for zero

特点：类似于 GCD 的信号量，但更直观面向对象，有更强的 wait 和 signal 操作性。

pthread_mutex

c 语言定义下的线程锁，其他好多锁都是对他的封装，也是性能相对最高的一个。

int pthread_mutex_init(pthread_mutex_t * __restrict, const pthread_mutexattr_t * _Nullable __restrict);

int pthread_mutex_lock(pthread_mutex_t *);

int pthread_mutex_trylock(pthread_mutex_t *);

int pthread_mutex_unlock(pthread_mutex_t *);

int pthread_mutexattr_settype(pthread_mutexattr_t *, int);

int pthread_mutexattr_destroy(pthread_mutexattr_t *) __DARWIN_ALIAS(pthread_mutexattr_destroy);

c 语言下提供了很多有关的操作 API，这里不多说，只列了常用这几个。

pthread_mutex_init：动态创建一个锁，第二个参数，NULL 为默认类型，一共用四种类型：

PTHREAD_MUTEX_NORMAL ：缺省类型，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后先进先出原则获得锁。

PTHREAD_MUTEX_ERRORCHECK ：检错锁，如果同一个线程请求同一个锁，则返回 EDEADLK，否则与普通锁类型动作相同。这样就保证当不允许多次加锁时不会出现嵌套情况下的死锁。

PTHREAD_MUTEX_RECURSIVE ：递归锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock 解锁。

PTHREAD_MUTEX_DEFAULT ：适应锁，动作最简单的锁类型，仅等待解锁后重新竞争，没有等待队列。

还有一种静态创建的方式：pthread_mutex_tmutex = PTHREAD_MUTEX_INITIALIZER static 或者全局变量。

pthread_mutexattr_settype：可以用来设置锁的类型，比如递归锁。

static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

// __block pthread_mutex_t lock;

// pthread_mutex_init(&lock, PTHREAD_MUTEX_NORMAL);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

pthread_mutex_lock(&lock);

NSLog(@"操作1开始");

sleep(3);

NSLog(@"操作1结束");

pthread_mutex_unlock(&lock);

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

sleep(1);

pthread_mutex_lock(&lock);

NSLog(@"操作2");

pthread_mutex_unlock(&lock);

});

以上代码执行结果为：

2018-08-16 16:31:19.333924+0800 Looks[6291:445780] 操作1开始

2018-08-16 16:31:22.339330+0800 Looks[6291:445780] 操作1结束

2018-08-16 16:31:22.339820+0800 Looks[6291:445781] 操作2

特点：基于 c 语言的 API，性能相对是最好的，可操作性更强，但 API 较多。

OSSpinLock

OSSpinLock 自旋锁，在线程阻塞等待的时候会一直轮询状态，这样在等待的时候会消耗大量资源。不过有 bug，已被弃用，弃用原因为：如果一个低优先级的线程获得锁并访问共享资源，这时一个高优先级的线程也尝试获得这个锁，它会处于 spinlock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺 CPU 时间，从而导致任务迟迟完不成、无法释放lock。所以 apple 的停用了 OSSpinLock, 所以在这不在做过多的介绍。

weixin_39948111

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程 c语言改变线程优先级,线程安全

多线程的存在导致在不同线程执行任务存在了数据、操作的不安全性，称之为非原子性。为了解决开发遇到的线程不安全的现象，就要用到线程锁。分别有 @synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock，不同的锁有不同的使用场景和性能上的区别。@synchronized@synchronized(objc) 为...
复制链接

扫一扫