iOS开发过程中的各种锁
2017-04-02 本文已影响52人
SDBridge
各种锁的效率图
iOS锁的效率.png
//
// ViewController.m
// LockKata1
//
// Created by Code_Hou on 2017/4/2.
// Copyright © 2017年 侯森魁. All rights reserved.
//
#import "ViewController.h"
#import <libkern/OSAtomic.h>
#import <pthread.h>
@interface ViewController ()
@end
@implementation ViewController
#pragma mark--自旋锁
/*
void OSSpinLockh_hsk(){
__block OSSpinLock oslosk =OS_SPINLOCK_INIT;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 准备上锁 当前线程 ");
OSSpinLockLock(&oslosk);
sleep(4);
NSLog(@"线程1");
OSSpinLockUnlock(&oslosk);
NSLog(@"线程1 解锁成功");
NSLog(@"-----------------------------");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 准备上锁");
OSSpinLockLock(&oslosk);
NSLog(@"线程2");
OSSpinLockUnlock(&oslosk);
NSLog(@"线程2 解锁成功");
});
}
*/
/*
控制台：
function:__OSSpinLockh_hsk_block_invoke line:26 content:线程1 准备上锁 当前线程 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke.16 line:39 content:线程2 准备上锁 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke line:30 content:线程1 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke line:32 content:线程1 解锁成功 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke line:33 content:----------------------------- 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke.16 line:41 content:线程2 🙃Multi Threaded
function:__OSSpinLockh_hsk_block_invoke.16 line:43 content:线程2 解锁成功 🙃Multi Threaded
*/
#pragma mark----信号量
void dispatch_semaphore(){
dispatch_semaphore_t signal =dispatch_semaphore_create(0);//传入值必须>=0,若传入为0则阻塞线程并等待tiomout,时间到后会执行其后的语句
dispatch_time_t overTime =dispatch_time(DISPATCH_TIME_NOW, 3.0f*NSEC_PER_SEC);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 等待ing");
dispatch_semaphore_wait(signal, overTime);//signal 值 -1
NSLog(@"线程1");
dispatch_semaphore_signal(signal);//signal 值+1
NSLog(@"线程1 发送信号");
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 等待ing");
dispatch_semaphore_wait(signal, overTime);
NSLog(@"线程2");
dispatch_semaphore_signal(signal);
NSLog(@"线程2 发送信号");
});
/*
传入1 overTime 不会生效
dispatch_semaphore_t signal =dispatch_semaphore_create(1);
控制台：
某一次:
2017-04-02 09:02:26.193 LockKata1[1336:38092] 线程1 等待ing
2017-04-02 09:02:26.194 LockKata1[1336:38092] 线程1
2017-04-02 09:02:26.193 LockKata1[1336:38096] 线程2 等待ing
2017-04-02 09:02:26.194 LockKata1[1336:38092] 线程1 发送信号
2017-04-02 09:02:26.194 LockKata1[1336:38096] 线程2
2017-04-02 09:02:26.195 LockKata1[1336:38096] 线程2 发送信号
某一次:
2017-04-02 09:03:11.098 LockKata1[1353:38732] 线程1 等待ing
2017-04-02 09:03:11.098 LockKata1[1353:38735] 线程2 等待ing
2017-04-02 09:03:11.098 LockKata1[1353:38732] 线程1
2017-04-02 09:03:11.100 LockKata1[1353:38732] 线程1 发送信号
2017-04-02 09:03:11.100 LockKata1[1353:38735] 线程2
2017-04-02 09:03:11.101 LockKata1[1353:38735] 线程2 发送信号
传入0 overTime 生效
dispatch_semaphore_t signal =dispatch_semaphore_create(0)
控制台:
2017-04-02 09:06:53.872 LockKata1[1376:41653] 线程1 等待ing
2017-04-02 09:06:53.872 LockKata1[1376:41638] 线程2 等待ing
2017-04-02 09:06:56.946 LockKata1[1376:41653] 线程1
2017-04-02 09:06:56.946 LockKata1[1376:41638] 线程2
2017-04-02 09:06:56.946 LockKata1[1376:41638] 线程2 发送信号
2017-04-02 09:06:56.946 LockKata1[1376:41653] 线程1 发送信号
*/
}
#pragma mark--互斥锁
void pthread_mutex_hsk(){
pthread_mutex_t pLock = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
// pthread_mutex_t_init(&pLock,NULL);
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//子线程网络请求
NSLog(@"线程1 准备上锁");
pthread_mutex_lock(&pLock);
sleep(3);
NSLog(@"线程1");
pthread_mutex_unlock(&pLock);
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//子线程网络请求
NSLog(@"线程2 准备上锁");
pthread_mutex_lock(&pLock);
NSLog(@"线程2");
pthread_mutex_unlock(&pLock);
});
/*
lock 和unlock 成对出现
*/
/*
控制台日志:
2017-04-02 09:33:21.575 LockKata1[1493:57547] 线程2 准备上锁
2017-04-02 09:33:21.575 LockKata1[1493:57545] 线程1 准备上锁
2017-04-02 09:33:21.576 LockKata1[1493:57547] 线程2
2017-04-02 09:33:24.646 LockKata1[1493:57545] 线程1
*/
}
#pragma mark---递归锁
void pthread_mutex_recursive(){
static pthread_mutex_t pLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);//初始化attr并且给它赋予默认值
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);//设置锁类型，这里设置为递归锁
pthread_mutex_init(&pLock, &attr);
pthread_mutexattr_destroy(&attr);//销毁一个属性对象，在重新进行初始化之前改结构不能重新使用
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveBlock)(int);
RecursiveBlock = ^(int value){
pthread_mutex_lock(&pLock);
if (value > 0) {
NSLog(@"value:%d",value);
RecursiveBlock(value-1);
}
pthread_mutex_unlock(&pLock);
};
RecursiveBlock(5);
});
/*
上面的代码如果我们用 pthread_mutex_init(&pLock, NULL) 初始化会出现死锁的情况，递归锁能很好的避免这种情况的死锁；
*/
/*
控制台日志:
2017-04-02 09:58:24.701 LockKata1[1591:70699] value:5
2017-04-02 09:58:24.701 LockKata1[1591:70699] value:4
2017-04-02 09:58:24.703 LockKata1[1591:70699] value:3
2017-04-02 09:58:24.704 LockKata1[1591:70699] value:2
2017-04-02 09:58:24.705 LockKata1[1591:70699] value:1
*/
}
#pragma mark---NSLock
void NSLock_hsk(){
NSLock *lock = [NSLock new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 尝试加锁ing...");
[lock lock];
sleep(3);//睡眠3秒
NSLog(@"线程1");
[lock unlock];
NSLog(@"线程1解锁成功");
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 尝试加锁ing...");
BOOL x = [lock lockBeforeDate:[NSDate dateWithTimeIntervalSinceNow:6]];
if (x) {
NSLog(@"线程2");
[lock unlock];
}else{
NSLog(@"失败");
}
});
/*
2017-04-02 10:10:25.265 LockKata1[1663:78655] 线程1 尝试加锁ing...
2017-04-02 10:10:25.265 LockKata1[1663:78654] 线程2 尝试加锁ing...
2017-04-02 10:10:28.334 LockKata1[1663:78655] 线程1
2017-04-02 10:10:28.334 LockKata1[1663:78654] 线程2
2017-04-02 10:10:28.334 LockKata1[1663:78655] 线程1解锁成功
*/
}
#pragma mark---NSCondition
void NSCondition_hsk(){
NSCondition *cLock = [NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"start");
[cLock lock];
[cLock waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];
//等待2 秒
NSLog(@"线程1");
[cLock unlock];
});
/*
*/
/*
2017-04-02 10:16:21.217 LockKata1[1709:82528] start
2017-04-02 10:16:23.287 LockKata1[1709:82528] 线程1
*/
}
void NSCondition_hsk1(){
NSCondition *cLock =[NSCondition new];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[cLock lock];
NSLog(@"线程1加锁成功");
[cLock wait];
NSLog(@"线程1");
[cLock unlock];
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[cLock lock];
NSLog(@"线程2加锁成功");
[cLock wait];
NSLog(@"线程2");
[cLock unlock];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(2);
NSLog(@"唤醒一个等待的线程");
[cLock broadcast];
});
/*
[cLock signal]
控制台日志:
2017-04-02 10:26:38.063 LockKata1[1751:87871] 线程1加锁成功
2017-04-02 10:26:38.064 LockKata1[1751:87872] 线程2加锁成功
2017-04-02 10:26:40.134 LockKata1[1751:87874] 唤醒一个等待的线程
2017-04-02 10:26:40.135 LockKata1[1751:87871] 线程1
[cLock broadcast];
控制台日志:
2017-04-02 10:36:34.442 LockKata1[1782:91902] 线程1加锁成功
2017-04-02 10:36:34.443 LockKata1[1782:91900] 线程2加锁成功
2017-04-02 10:36:36.504 LockKata1[1782:91899] 唤醒一个等待的线程
2017-04-02 10:36:36.505 LockKata1[1782:91902] 线程1
2017-04-02 10:36:36.506 LockKata1[1782:91900] 线程2
*/
}
#pragma mark--经典错误例子
//我在这里写的C方法 在AppDelegate.m方法中一样能调用，(*@ο@*) 哇～，夸类了，还是 C语言好
void errorUseWithNSLock(){
NSLock *rLock = [NSLock new];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void(^RecursiveBlock)(int);
RecursiveBlock = ^(int value){
[rLock lock];
if (value>0) {
NSLog(@"线程%d",value);
RecursiveBlock(value - 1);
}
[rLock unlock];
};
RecursiveBlock(4);
});
/*
这是一段典型的死锁情况。在我们的线程中，RecursiveMethod是递归调用的。所以每次进入这个block时，都会去加一次锁，而从第二次开始，由于锁已经被使用了且没有解锁，所以它需要等待锁被解除，这样就导致了死锁，线程被阻塞住了。
控制台日志:
2017-04-02 10:47:37.882 LockKata1[1823:97654] 线程4
2017-04-02 10:47:37.883 LockKata1[1823:97654] *** -[NSLock lock]: deadlock (<NSLock: 0x7b858f80> '(null)')
2017-04-02 10:47:37.884 LockKata1[1823:97654] *** Break on _NSLockError() to debug.
*/
}
void NSRecursiveLock_hsk(){
NSRecursiveLock *rLock =[NSRecursiveLock new];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void(^RecursiveBlock)(int);
RecursiveBlock = ^(int value){
[rLock lock];
if (value>0) {
NSLog(@"线程%d",value);
RecursiveBlock(value-1);
}
[rLock unlock];
};
RecursiveBlock(5);
});
/*
控制台:
2017-04-02 10:55:48.718 LockKata1[1855:100893] 线程5
2017-04-02 10:55:48.718 LockKata1[1855:100893] 线程4
2017-04-02 10:55:48.719 LockKata1[1855:100893] 线程3
2017-04-02 10:55:48.721 LockKata1[1855:100893] 线程2
2017-04-02 10:55:48.725 LockKata1[1855:100893] 线程1
*/
}
#pragma mark----@synchronized 条件锁
- (void) synchronized_hsk{
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
@synchronized (self) {
sleep(2);
NSLog(@"线程1");
}
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
@synchronized (self) {
NSLog(@"线程2");
}
});
/*
2017-04-02 11:03:11.972 LockKata1[1885:104889] 线程2
2017-04-02 11:03:14.013 LockKata1[1885:104890] 线程1
*/
}
void NSConditonLock_hsk(){
NSConditionLock *cLock =[[NSConditionLock alloc]initWithCondition:0];
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
if ([cLock tryLockWhenCondition:0]) {
NSLog(@"线程1");
[cLock unlockWithCondition:1];
}else{
NSLog(@"失败");
}
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[cLock lockWhenCondition:3];
NSLog(@"线程2");
[cLock unlockWithCondition:2];
});
//线程3
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[cLock lockWhenCondition:1];
NSLog(@"线程3");
[cLock unlockWithCondition:3];
});
/*
我们在初始化NSConditionLock对象时，给了他的标示为0
执行tryLockWhenCondition:时，我们传入的条件标示也是0，所以线程1加锁成功
执行 unlockWithCondition:时，这时候会把condition由0 修改为1
因为condition修改为了1，会先走到线程3，然后线程3又将condition修改为3，最后走了线程2的流程
从上面的结果我们可以发现，NSConditionLock还可以实现任务之间的依赖。
控制台日志:
2017-04-02 11:10:25.099 LockKata1[1914:108665] 线程1
2017-04-02 11:10:25.101 LockKata1[1914:108667] 线程3
2017-04-02 11:10:25.101 LockKata1[1914:108664] 线程2
*/
}
- (void)viewDidLoad {
[super viewDidLoad];
NSConditonLock_hsk();
}
- (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
}
@end
