iOS —— 多线程应用

一、共享资源

共享资源 : 就是内存中的一块资源同时被多个进程所访问，而每个进程可能会对该资源的数据进行修改

问题 : 如果 线程A 访问了某块资源 C，并且修改了其中的数据，此时 线程B 也访问了 资源C，并且也对 C 中的数据进行了修改；那么等到 线程A 和 线程B 执行结束后，此时，资源C 中的数据就并不是最初的设置了

 

如图

 

此时，如果用户想获取 被 线程A 修改的 资源C 的数据，但是 资源C 的数据也被 线程B 修改了，所以获得的是错误的数据；如果用户想获取 被 线程B 修改的 资源C 的数据，但是 资源C 的数据也被 线程A 修改了，所以获得的是错误的数据

 

下面看代码，以出售火车票为例

建立火车票数据模型

 

// LHTicketModal.h
#import <Foundation/Foundation.h>

@interface LHTicketModal : NSObject

@property (nonatomic) NSUInteger ticketCount;       // 剩余票数
@property (nonatomic) NSUInteger ticketSaleCount;   // 卖出数量

@end

// LHTicketModal.m
#import "LHTicketModal.h"

static const NSUInteger kTicketTotalCount = 50;

@implementation LHTicketModal

- (instancetype)init {

    self = [super init];
    
    if (self) {
    
        // 初始化剩余票数应该为总数
        _ticketCount = kTicketTotalCount;
        
        // 初始化卖出票数应该为 0
        _ticketSaleCount = 0;
    
    }
    
    return self;

}

@end

 

 

UIViewController 代码，声明两个线程，分别代表两个地点

// LHSharedViewController.h
#import "LHSharedViewController.h"
#import "LHTicketModal.h"

@interface LHSharedViewController ()

// 车票模型
@property (nonatomic, strong) LHTicketModal * ticket;

// 线程对象
@property (nonatomic, strong) NSThread * threadBJ;
@property (nonatomic, strong) NSThread * threadSH;

@end

// LHSharedViewController.m
@implementation LHSharedViewController

- (void)viewDidLoad {
    
    [super viewDidLoad];
    
    // 1. 初始化 票数模型对象
    _ticket = [[LHTicketModal alloc] init];
    
    // 2. 初始化 线程对象 并设置线程名
    _threadBJ = [[NSThread alloc] initWithTarget:self selector:@selector(sellTickets:) object:@"北京卖出"];
    
    _threadBJ.name = @"北京";
    
    _threadSH = [[NSThread alloc] initWithTarget:self selector:@selector(sellTickets:) object:@"上海卖出"];
    
    _threadSH.name = @"上海";

}

// 线程执行的方法
- (void)sellTickets:(NSString *)str {

    while (YES) {
    
        // 判断剩余量是否大于 0，大于 0 才可以卖出
        if (_ticket.ticketCount > 0) {
        
            // 暂停一段时间
            [NSThread sleepForTimeInterval:0.2];
            
            // 卖出一张票，剩余票数减 1，卖出票数加 1
            _ticket.ticketCount--;
            
            _ticket.ticketSaleCount++;
            
            // 获取当前进程
            NSThread * currentThread = [NSThread currentThread];
            
            NSLog(@"%@ 卖了一张票，还剩 %lu 张票", currentThread.name, _ticket.ticketCount);
            
        }
    
    }

}

// 按钮的动作方法
- (IBAction)startSaleBtnClick:(id)sender {
    
    // 开启线程
    [_threadBJ start];
    
    [_threadSH start];
    
    
}

点击按钮后，线程开始运行，结果如图

 

看一看出，共享资源同时被多个线程访问并修改，导致用户取得了错误的数据

 

那么解决这种情况的办法就是 加锁

加锁是指对一段代码进行加锁，加锁之后，若一个线程已经在对共享资源的数据修改，此时就不会再有其他线程来访问该资源进行修改，直至当前线程已经结束修改资源的代码时，其他进程才可以对其进行修改

可以把共享资源看做一个房间，线程看做人；当一个人进入房间之后就会锁门（加锁），对房间进行各种布置，此时其他人是进不来的，因为没有钥匙；直至当前的人出房间，其他的人才可以进房间进行布置

 

加锁的方式有多种，这里介绍两种

方式一 : 使用  @synchronized (加锁对象) {} 关键字

只需修改上述代码的  sellTickets 方法，其余不变，这里将其方法名改为  sellTickets_v2

- (void)sellTickets_v2:(NSString *)str {
    
    while (YES) {
        
        // 对当前对象加锁
        @synchronized (self) {
            
            // 判断剩余量是否大于 0，大于 0 才可以卖出
            if (_ticket.ticketCount > 0) {
            
                // 暂停一段时间
                [NSThread sleepForTimeInterval:0.2];
            
                // 卖出一张票，剩余票数减 1，卖出票数加 1
                _ticket.ticketCount--;
            
                _ticket.ticketSaleCount++;
            
                // 获取当前进程
                NSThread * currentThread = [NSThread currentThread];
            
                NSLog(@"%@ 卖了一张票，还剩 %lu 张票", currentThread.name, _ticket.ticketCount);
            
            }
            
        }
        
    }
    
}

再次运行程序，点击按钮。结果如图

 

 

方式二 : 使用 NSCondition 类

在 类扩展中声明并在 viewDidLoad 方法中初始化

 

- (void)sellTickets_v3:(NSString *)str {
    
    while (YES) {
        
        // 使用 NSCondition 加锁
        [_ticketCondition lock];
        
        // 判断剩余量是否大于 0，大于 0 才可以卖出
        if (_ticket.ticketCount > 0) {
                
            // 暂停一段时间
            [NSThread sleepForTimeInterval:0.2];
                
            // 卖出一张票，剩余票数减 1，卖出票数加 1
            _ticket.ticketCount--;
                
            _ticket.ticketSaleCount++;
                
            // 获取当前进程
            NSThread * currentThread = [NSThread currentThread];
                
            NSLog(@"%@ 卖了一张票，还剩 %lu 张票", currentThread.name, _ticket.ticketCount);
            
        }
        
        // 使用 NSCondition 解锁
        [_ticketCondition unlock];
        
    }
    
}

 

运行结果和上述一样

使用 NSCondition 时，将加锁的代码放在 loac 和 unlock 中间

 

总结 :

　　1. 互斥锁的优缺点

　　　　优点 : 有效防止因多线程抢夺资源造成的数据安全问题

　　　　缺点 : 需要消耗大量 CPU 资源

 

　　2. 互斥锁使用的前提

　　　　多个线程抢夺同一资源

　　　　线程同步，互斥锁就是使用了线程同步　　

 

二、线程通信

通常， 一个线程不应该单独存在，应该和其他线程之间有关系

例如 : 一个线程完成了自己的任务后需要切换到另一个线程完成某个任务；或者 一个线程将数据传递给另一个线程

看代码，现在 xib 中拖入一个 按钮，并设置其动作方法，如下

 

- (IBAction)btn1Click:(id)sender {
    
    // 1. 获取主线程
    NSLog(@"mainThread --- %@", [NSThread mainThread]);
    
    // 2. 创建子线程并完成指定的任务
    [self performSelectorInBackground:@selector(run1:) withObject:@"子线程中执行方法"];
    
}

- (void)run1:(NSString *)str {

    // 1. 获取当前线程
    NSThread * currentThread = [NSThread currentThread];
    
    NSLog(@"currentThread --- %@ --- %@", currentThread, str);
    
    // 2. 回到主线程中执行指定的方法
    [self performSelectorOnMainThread:@selector(backMainThread:) withObject:@"回到主线程" waitUntilDone:YES];

}

- (void)backMainThread:(NSString *)str {

    // 1. 获取当前线程（主线程）
    NSThread * currentThread = [NSThread currentThread];
    
    NSLog(@"currentThread --- %@ --- %@", currentThread, str);

}

 

这里通过 performSelectorInBackground: withObject: 方法创建一个子线程并完成指定的任务（run1:），然后在子线程中又通过 

performSelectorOnMainThread: withObject: waitUntilDone: 方法回到主线程中完成指定的任务（backMainThread:）

点击按钮，运行结果如下

 

 三、线程的状态

1. 当一个线程对象创建并开启后，它就会被放到线程调度池中，等待系统调度；如图

 

2. 当正在运行的线程被阻塞时，就会被移出 可调度线程池，此时不可再调度它

 

3. 当线程正常结束，异常退出，强制退出时都会导致该线程死亡，死亡的线程会从内存中移除，无法调度

 

代码如下

在 xib 中拖入一个 按钮，并设置其动作方法

 

#import "LHThreadStateViewController.h"

@interface LHThreadStateViewController ()

@property (nonatomic, strong) NSThread * thread;

@end

@implementation LHThreadStateViewController

- (void)viewDidLoad {
    
    [super viewDidLoad];
    
    // 1. 初始化线程对象
    _thread = [[NSThread alloc] initWithTarget:self selector:@selector(runThread:) object:@"子线程执行任务"];
    
    _thread.name = @"线程A";

}

- (IBAction)startThreadClick:(id)sender {
    
    // 1. 获取主线程
    NSLog(@"mainThread --- %@", [NSThread mainThread]);
    
    // 线程开始
    [_thread start];
    
}

- (void)runThread:(NSString *)str {

    // 1. 获取当前线程
    NSThread * currentThread = [NSThread currentThread];
    
    NSLog(@"currentThread --- %@", currentThread);
    
    // 2. 阻塞 2s
    NSLog(@"线程开始阻塞 2s");
    
    [NSThread sleepForTimeInterval:2.0];
    
    NSLog(@"线程结束阻塞 2s");
    
    // 3. 阻塞 4s
    NSLog(@"线程开始阻塞 4s");
    
    // 创建 NSDate 对象，并从当前开始推后 4s
    NSDate * date = [NSDate dateWithTimeIntervalSinceNow:4.0];
    
    [NSThread sleepUntilDate:date];
    
    NSLog(@"线程结束阻塞 4s");
    
    // 4. 退出线程
    for (int i = 0; i < 10; ++i) {
    
        if (i == 7) {
        
            // 结束当前线程，之后的语句不会再执行
            [NSThread exit];
            
            NSLog(@"线程结束");
        
        }
        
        NSLog(@"%i --- %@", i, currentThread);
    
    }

}

 

42 行使用 sleepForTimeInterval: 方法使得当前线程阻塞指定的时间

52 行使用 sleepUntilDate: 方法使得当前线程阻塞 参数中设定的时间；该参数必须是 NSDate 对象，并且以当前时间作为基准

62 行使用 exit 方法退出当前线程，并且退出后，该方法之后的语句不再会执行，上述中即 64 行代码不会执行

点击按钮，运行结果如下

注意 : 当 执行 exit 方法后，表示当前的线程已经死亡，即从内存中移除了，若此时再点击按钮（该线程在内存中已经没有空间了），程序会崩溃，并报以下的错误