Imkata
Imkata

iOS-多线程3-加锁方案2

一. NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值。

NSConditionLock相关API：

@interface NSConditionLock : NSObject  {

- (instancetype)initWithCondition:(NSInteger)condition;

@property (readonly) NSInteger condition; //条件值

- (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;

@property (nullable, copy) NSString *name;

@end

简单使用如下：

#import "NSConditionLockDemo.h"

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    //线程1
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    //线程2
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    //线程3
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lockWhenCondition:1];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}
@end

可以发现，三个子线程同时执行代码，最后打印结果是：

__one
__two
__three

先执行线程1，再执行线程2，再执行线程3，达到线程3依赖线程2，线程2依赖线程1的效果。

使用场景：

如果子线程有依赖关系(子线程的执行是有顺序的)，就可以使用NSConditionLock，设置条件具体的值。

在GNUstep中查看源码：

- (id) init
{
    return [self initWithCondition: 0];
}

- (id) initWithCondition: (NSInteger)value
{
    if (nil != (self = [super init]))
    {
        if (nil == (_condition = [NSCondition new]))
        {
            DESTROY(self);
        }
        else
        {
            _condition_value = value;
            [_condition setName:
             [NSString stringWithFormat: @"condition-for-lock-%p", self]];
        }
    }
    return self;
}

可以发现两个问题：

  1. 条件值默认是0
  2. NSConditionLock的确是对NSCondition的封装

二. dispatch_queue(DISPATCH_QUEUE_SERIAL)

直接使用GCD的串行队列，也是可以实现线程同步的

#import "SerialQueueDemo.h"

@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end

@implementation SerialQueueDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
        self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __drawMoney];
    });
}

- (void)__saveMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __saveMoney];
    });
}

- (void)__saleTicket
{
    dispatch_sync(self.ticketQueue, ^{
        [super __saleTicket];
    });
}
@end

dispatch_sync函数的特点：要求立马在当前线程同步执行任务（当前线程是子线程，在MJBaseDemo里面已经写了）。

本来这个方法就是在子线程中执行的，把存钱、取钱操作放到一个串行队列里面，把卖票操作放到另一个串行队列里面。

举例说明：比如线程4进来卖票，那么这个操作就会被放到串行队列中，等一会线程7又进来卖票，这个操作也会被放到串行队列中，串行队列里面的东西是：线程4的卖票操作 - 线程7的卖票操作 - 线程5的卖票操作。

这样线程4卖完，线程7卖，线程7卖完，线程5卖。这样串行队列中的任务是异步的，不会出现多个线程同时访问一个成员变量的问题，这样也能解决线程安全问题。

所以说，线程同步问题也不是必须要通过加锁才能实现。

三. dispatch_semaphore

  1. semaphore叫做”信号量”
  2. 信号量的初始值，可以用来控制线程并发访问的最大数量
  3. 信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

如下代码，创建15条线程，都调用test方法：

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@end

@implementation SemaphoreDemo
- (void)viewDidLoad {
   [super viewDidLoad]

    self.semaphore = dispatch_semaphore_create(5);

    for (int i = 0; i < 15; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
    }
}

// 线程10、7、6、9、8
- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    // 第二个参数代表等到啥时候，传入的DISPATCH_TIME_FOREVER，代表一直等
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}
@end

打印：

test - {number = 7, name = (null)}
test - {number = 9, name = (null)}
test - {number = 8, name = (null)}
test - {number = 10, name = (null)}
test - {number = 4, name = (null)}
    间隔2秒
test - {number = 12, name = (null)}
test - {number = 11, name = (null)}
test - {number = 13, name = (null)}
test - {number = 5, name = (null)}
test - {number = 14, name = (null)}
    间隔2秒
test - {number = 15, name = (null)}
test - {number = 16, name = (null)}
test - {number = 17, name = (null)}
test - {number = 6, name = (null)}
test - {number = 3, name = (null)}

上面代码，创建了15条线程，如果不控制线程并发访问的最大数量，那么有可能15条线程同时访问test方法，这样就不安全。使用了信号量，发现最多只有5条线程访问test，这5条访问完，后面5条线程继续访问。

所以，如果信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步，代码如下：

#import "SemaphoreDemo.h"

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
@property (strong, nonatomic) dispatch_semaphore_t moneySemaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
        //设置信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
        self.ticketSemaphore = dispatch_semaphore_create(1);
        self.moneySemaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __drawMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saveMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saveMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saleTicket
{
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saleTicket];
    
    dispatch_semaphore_signal(self.ticketSemaphore);
}

信号量原理：

dispatch_semaphore_t ticketSemaphore = dispatch_semaphore_create(1);
//如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
//如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
//第二个参数代表等到啥时候，传入的DISPATCH_TIME_FOREVER，代表一直等
dispatch_semaphore_wait(ticketSemaphore, DISPATCH_TIME_FOREVER);
......
//让信号量的值+1
dispatch_semaphore_signal(ticketSemaphore);

小提示：控制线程并发访问的最大数量也可以用

NSOperationQueue *queue;
queue.maxConcurrentOperationCount = 5;

四. @synchronized

  1. @synchronized是对mutex递归锁的封装
  2. @synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

使用如下：

#import "SynchronizedDemo.h"

@implementation SynchronizedDemo

- (void)__drawMoney
{
    //最简单的一种方式，但是性能比较差，苹果不推荐使用，所以打出来的时候没提示。
    //其中()中是拿什么当做一把锁，比如下面是拿当前类对象当做一把锁。
    //为什么把类对象当做一把锁？因为类对象只有一个，以后无论什么实例对象调用这个方法，都是类对象作为锁，这样就只有一把锁，才能锁住。
    @synchronized([self class]) {
        [super __drawMoney];
    }
}

- (void)__saveMoney
{
    @synchronized([self class]) { // objc_sync_enter
        [super __saveMoney];
    } // objc_sync_exit
}

- (void)__saleTicket
{
    //除了用类对象作为一把锁，也可以直接传入一个其他对象，并且要dispatch_once_t，保证以后不管调用多少次都是同一个对象。
    static NSObject *lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        lock = [[NSObject alloc] init];
    });
    
    @synchronized(lock) {
        [super __saleTicket];
    }
}
@end

在@synchronized处打断点，查看汇编，可以发现会调用objc_sync_enter和objc_sync_exit。就相当于，第一个“{”是objc_sync_enter，第二个“}”是objc_sync_exit，如下：

@synchronized([self class]) { // objc_sync_enter
......
} // objc_sync_exit

然后在objc4中的objc-sync.mm文件中查看objc_sync_enter函数的源码实现：

typedef struct SyncData {
    struct SyncData* nextData;
    DisguisedPtr object;
    int32_t threadCount;  
    recursive_mutex_t mutex; //递归锁
} SyncData;

int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;

    if (obj) {//将传进来的obj转成data
        SyncData* data = id2data(obj, ACQUIRE);
        assert(data);
        data->mutex.lock();//再从data里面取出一把递归锁，所以只要obj一样，取出的锁也一样
    } else {
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }

    return result;
}

从上面代码可以看出，将传进来的obj转成data，再从data里面取出一把递归锁，所以只要obj一样，取出的锁也一样，所以我们上面才说传入的obj要唯一。

递归锁：允许同一个线程对一把锁进行重复加锁(解锁)

既然@synchronized是递归锁，那么肯定可以做递归锁可以做的事情，如下：

- (void)otherTest {
    @synchronized([self class]) {
        NSLog(@"123");
        //递归调用10次
        static int count = 0;
        if (count < 10) {
            count++;
            [self otherTest];
        }
    }
}

上面代码，递归调用10次，最后打印10次“123”。如果将@synchronized换成其他锁，递归调用就会造成死锁，最后结果打印了10次，说明的确是递归锁。

注意：@synchronized和@synthesize、@dynamic不一样，别弄混淆了，关于@synthesize、@dynamic可参考Runtime3-objc_msgSend底层调用流程的补充内容。

五. 总结：回忆一下前面学的各种锁

OSSpinLock 自旋锁，因为底层是使用while循环进行忙等，不会进行休眠和唤醒，所以是性能比较高的一把锁，但是现在已经不安全，被抛弃。

os_unfair_lock 用于取代不安全的OSSpinLock ，从iOS10开始才支持。从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等，是一种互斥锁。

pthread_mutex mutex叫做”互斥锁”，等待锁的线程会处于休眠状态。
它是跨平台的，当传入的类型是默认的就是默认锁，当传入PTHREAD_MUTEX_RECURSIVE，就是递归锁，还可以通过pthread_cond_wait(&_cond, &_mutex)当做条件锁来使用。

dispatch_semaphore 信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

dispatch_queue(DISPATCH_QUEUE_SERIAL) 直接使用GCD的串行队列，也是可以实现线程同步的

NSLock是对mutex普通锁的封装
NSRecursiveLock是对mutex递归锁的封装，API跟NSLock基本一致
NSCondition是对mutex和cond的封装
NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值

@synchronized也是对mutex递归锁的封装
@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

六. 各种锁性能比较

自此，iOS中各种锁基本上都讲完了，下面比较一下性能，然后找出一个最好的，留着开发中使用。

性能从高到低排序：

os_unfair_lock iOS10开始支持
OSSpinLock 不安全，被抛弃
dispatch_semaphore 如果需要iOS8、9都支持可以使用
pthread_mutex 可以跨平台
dispatch_queue(DISPATCH_QUEUE_SERIAL) 本来GCD效率就很高
NSLock 对mutex普通锁的封装
NSCondition 对mutex和cond的封装
pthread_mutex(recursive) mutex递归锁，递归锁效率本来就低
NSRecursiveLock 对mutex递归锁的封装
NSConditionLock 对NSCondition的封装
@synchronized 对mutex递归锁的封装

总结：

一般推荐使用os_unfair_lock、dispatch_semaphore、pthread_mutex。

使用技巧：

对于dispatch_semaphore来说，如果下面每个方法的锁都是不一样的，我们可以写成下面这样的宏：

#define SemaphoreBegin \
static dispatch_semaphore_t semaphore; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
    semaphore = dispatch_semaphore_create(1); \
}); \
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

#define SemaphoreEnd \
dispatch_semaphore_signal(semaphore);

使用如下：

- (void)test1
{
    SemaphoreBegin;
    // .....
    SemaphoreEnd;
}

- (void)test2
{
    SemaphoreBegin;
    // .....
    SemaphoreEnd;
}

- (void)test3
{
    SemaphoreBegin;
    // .....
    SemaphoreEnd;
}

这样就保证每个方法内部的锁都不一样，同时使用起来也很简单。

如果每个方法的锁都是一样的，那就只能把锁写到外面去了。
同理，pthread_mutex也可以这样封装。

七. 面试题

  1. 你理解的多线程？
    就是多条线程同时做事情，优点就是效率高，缺点就是可能会造成线程安全问题。

  2. iOS的多线程方案有哪几种？你更倾向于哪一种？
    多线程方案如下图，更倾向于GCD。

iOS-多线程3-加锁方案2_第1张图片
多线程方案.png

① 这些多线程方案的底层都是依赖pthread
② NSThread线程生命周期是程序员管理，GCD和NSOperation是系统自动管理
③ NSThread和NSOperation都是OC的，更加面向对象
④ NSOperation基于CGD，使用更加面向对象

  1. 你在项目中用过 GCD 吗？

  2. GCD 的队列类型？

  3. 说一下 OperationQueue 和 GCD 的区别，以及各自的优势有哪些？

  4. 线程安全的处理手段有哪些？
    上面讲的

  5. OC你了解的锁有哪些？在你回答基础上进行二次提问；
    追问一：自旋和互斥对比？
    追问二：使用以上锁需要注意哪些？
    追问三：用C/OC/C++，任选其一，实现自旋或互斥？口述即可！

  6. 自旋锁、互斥锁比较？
    自旋锁：顾名思义就是自己一直在旋转的锁，比如上面的OSSpinLock，它底层是个while循环。
    互斥锁：互斥锁提供一个可以在同一时间，只让一个线程访问临界资源的操作接口。互斥锁(Mutex)是个提供线程同步的基本锁。上锁后，其他的线程如果想要锁上，那么会被阻塞(线程休眠)，直到锁释放后（说明，一般会把访问共享内存这段代码放在上锁程序之后）———百度百科

上面讲的那些锁，除了OSSpinLock是自旋锁，其他的都是互斥锁。

  1. 什么情况使用自旋锁比较划算？
    预计线程等待锁的时间很短
    加锁的代码（临界区）经常被调用，但竞争情况很少发生
    CPU资源不紧张
    多核处理器

  2. 什么情况使用互斥锁比较划算？
    预计线程等待锁的时间较长
    单核处理器
    临界区有IO操作，因为IO操作比较占用CPU资源
    临界区代码复杂或者循环量大
    临界区竞争非常激烈

八. atomic

nonatomic和atomic
atom：原子，不可再分割的单位
atomic：原子性

原子性操作就说明这个操作是个整体，不可分割的。
比如如下三行代码，如果不是原子性操作，那么这三行代码就有可能被三个线程执行，这样肯定是不行的，那怎么变成原子性操作呢？
在第一行前面加锁，第三行后面解锁，就变成了原子性操作，变成原子性操作之后要么不执行，要执行必须把三行一块执行完，如下：

 // 加锁
 int a = 10;
 int b = 20;
 int c = a + b;
 // 解锁

atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁，也就是setter和getter内部都有加锁操作。

在objc4的objc-accessors.mm文件找到如下源码：

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    if (copy) {
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);
    }

    if (!atomic) { //如果是nonatomic，就直接赋值
        oldValue = *slot;
        *slot = newValue;
    } else { //如果是atomic，就先加锁后解锁
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock(); //加锁
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock(); //解锁
    }

    objc_release(oldValue);
}

可以发现，setter方法里面，如果是nonatomic，就直接赋值，如果是atomic，就先加锁后解锁，getter方法也一样，就不解释了。

对于atomic，上面我们说了setter、getter方法内部会有加锁、解锁操作，但它并不能保证使用属性的过程是线程安全的，什么意思呢？

如下：

@interface MJPerson : NSObject
@property (strong, atomic) NSMutableArray *data; //atomic修饰
@end

//执行以下代码：
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MJPerson *p = [[MJPerson alloc] init];
        
        for (int i = 0; i < 10; i++) {
            dispatch_async(NULL, ^{
                p.data = [NSMutableArray array];
            });
        }
        
        NSMutableArray *array = p.data;
        // 没有加锁
        [array addObject:@"1"];
        [array addObject:@"2"];
        [array addObject:@"3"];
        // 没有解锁
    }
    return 0;
}

上面代码 p.data = [NSMutableArray array] 这一行是线程安全的，因为它的setter方法内部有加锁、解锁操作。
但是 [array addObject:@"1"] 这一行就不是线程安全的了，因为它没有加锁、解锁操作。

既然atomic是线程安全的，那么为什么开发中我们基本不用呢？

  1. 太耗性能了，因为setter、getter方法调用次数太频繁了，如果每次都需要加锁、解锁，那手机CPU资源不就被你消耗完了。所以atomic一般在MAC上才使用。

  2. 而且只有多条线程同时访问同一个对象的属性，才会有线程安全问题。这种情况几乎没有，如果你非要造出来这种情况，比如如下代码，多条线程同时访问 p.data ，那你完全可以在外面加锁嘛！

for (int i = 0; i < 10; i++) {
    dispatch_async(NULL, ^{
        // 在外面加锁
        p.data = [NSMutableArray array];
        // 在外面解锁
    });
}

九. 读写安全方案

显然，如果使用上面讲的加锁方案，那么无论读、写，同一时间只有一条线程在执行，这样效率比较低，实际上读操作可以同时多条线程一起执行的。

思考如何实现以下场景
同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许既有写的操作，又有读的操作

上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有：

  1. pthread_rwlock_t：读写锁
  2. dispatch_barrier_async：异步栅栏调用

1. pthread_rwlock_t

等待锁的线程会进入休眠（有点互斥锁的感觉）

代码如下：

#import "ViewController.h"
#import 

@interface ViewController ()
@property (assign, nonatomic) pthread_rwlock_t lock; //读写锁
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_rwlock_init(&_lock, NULL);
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    for (int i = 0; i < 10; i++) {
        //读
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self read];
        });
        //写
        dispatch_async(queue, ^{
            [self write];
        });
        dispatch_async(queue, ^{
            [self write];
        });
        dispatch_async(queue, ^{
            [self write];
        });
    }
}


- (void)read {
    
    //读-尝试加锁
    //pthread_rwlock_tryrdlock(&_lock);
    
    //读-加锁
    pthread_rwlock_rdlock(&_lock);
    
    sleep(1);
    NSLog(@"%s--线程：%@", __func__,[NSThread currentThread]);
    //解锁
    pthread_rwlock_unlock(&_lock);
}

- (void)write
{
    //写-尝试加锁
    //pthread_rwlock_trywrlock(&_lock);
    
    //写-加锁
    pthread_rwlock_wrlock(&_lock);
    
    sleep(1);
    NSLog(@"%s--线程：%@", __func__,[NSThread currentThread]);
    
    //解锁
    pthread_rwlock_unlock(&_lock);
}

- (void)dealloc
{
    //销毁
    pthread_rwlock_destroy(&_lock);
}
@end

打印：

2021-06-01 15:41:18.160200+0800 -[read]--线程：{number = 4, name = (null)}
2021-06-01 15:41:18.160212+0800 -[read]--线程：{number = 7, name = (null)}
2021-06-01 15:41:19.162515+0800 -[write]--线程：{number = 3, name = (null)}
2021-06-01 15:41:20.165942+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 15:41:21.166782+0800 -[write]--线程：{number = 8, name = (null)}
2021-06-01 15:41:22.172355+0800 -[write]--线程：{number = 9, name = (null)}
2021-06-01 15:41:23.176932+0800 -[read]--线程：{number = 10, name = (null)}
2021-06-01 15:41:23.176946+0800 -[read]--线程：{number = 11, name = (null)}
2021-06-01 15:41:23.176946+0800 -[read]--线程：{number = 12, name = (null)}
2021-06-01 15:41:24.182928+0800 -[write]--线程：{number = 13, name = (null)}
2021-06-01 15:41:25.188879+0800 -[write]--线程：{number = 14, name = (null)}
2021-06-01 15:41:26.189801+0800 -[write]--线程：{number = 15, name = (null)}
2021-06-01 15:41:27.194003+0800 -[read]--线程：{number = 18, name = (null)}
2021-06-01 15:41:27.193997+0800 -[read]--线程：{number = 17, name = (null)}
2021-06-01 15:41:27.193997+0800 -[read]--线程：{number = 16, name = (null)}
2021-06-01 15:41:28.194641+0800 -[write]--线程：{number = 19, name = (null)}
2021-06-01 15:41:29.198154+0800 -[write]--线程：{number = 20, name = (null)}
2021-06-01 15:41:30.203043+0800 -[write]--线程：{number = 21, name = (null)}
2021-06-01 15:41:31.208880+0800 -[read]--线程：{number = 22, name = (null)}
2021-06-01 15:41:31.208880+0800 -[read]--线程：{number = 24, name = (null)}
2021-06-01 15:41:31.208874+0800 -[read]--线程：{number = 23, name = (null)}
2021-06-01 15:41:32.209671+0800 -[write]--线程：{number = 25, name = (null)}
2021-06-01 15:41:33.215514+0800 -[write]--线程：{number = 26, name = (null)}
2021-06-01 15:41:34.221247+0800 -[write]--线程：{number = 27, name = (null)}
2021-06-01 15:41:35.227011+0800 -[read]--线程：{number = 29, name = (null)}
2021-06-01 15:41:35.227010+0800 -[read]--线程：{number = 28, name = (null)}
2021-06-01 15:41:35.227011+0800 -[read]--线程：{number = 30, name = (null)}
2021-06-01 15:41:36.231641+0800 -[write]--线程：{number = 31, name = (null)}
2021-06-01 15:41:37.237418+0800 -[write]--线程：{number = 32, name = (null)}
2021-06-01 15:41:38.243212+0800 -[write]--线程：{number = 33, name = (null)}

可以发现，读同时进行，写就不能同时进行了。

2. dispatch_barrier_async

废话少说，先看怎么使用，如下：

#import "ViewController.h"

@interface ViewController ()
@property (strong, nonatomic) dispatch_queue_t queue;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //手动创建并发队列
    self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i < 10; i++) {
        //读
        dispatch_async(self.queue, ^{
            [self read];
        });
        dispatch_async(self.queue, ^{
            [self read];
        });
        dispatch_async(self.queue, ^{
            [self read];
        });
        //写
        //当有一条线程在执行这个任务的时候，绝不允许queue中有其他线程在执行其他任务（包括上面的read和下面的write）
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
    }
}

- (void)read {
    sleep(1);
    NSLog(@"%s--线程：%@", __func__,[NSThread currentThread]);
}

- (void)write
{
    sleep(1);
    NSLog(@"%s--线程：%@", __func__,[NSThread currentThread]);
}
@end

打印如下：

2021-06-01 16:00:12.233462+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:00:12.233472+0800 -[read]--线程：{number = 3, name = (null)}
2021-06-01 16:00:12.233479+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:00:13.237569+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:14.239756+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:15.243263+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:16.248324+0800 -[read]--线程：{number = 3, name = (null)}
2021-06-01 16:00:16.248324+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:00:16.248324+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:00:17.253537+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:18.256256+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:19.257152+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:20.262030+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:00:20.262026+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:00:20.262049+0800 -[read]--线程：{number = 7, name = (null)}
2021-06-01 16:00:21.262937+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:22.268470+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:23.273291+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:24.279084+0800 -[read]--线程：{number = 7, name = (null)}
2021-06-01 16:00:24.279085+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:00:24.279085+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:00:25.281132+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:26.282865+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:27.286220+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:28.290012+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:00:28.290012+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:00:28.290012+0800 -[read]--线程：{number = 7, name = (null)}
2021-06-01 16:00:29.290888+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:30.296537+0800 -[write]--线程：{number = 6, name = (null)}
2021-06-01 16:00:31.301259+0800 -[write]--线程：{number = 6, name = (null)}

可以发现，打印结果和读写锁一样，读同时进行，写就不能同时进行，说明dispatch_barrier_async在文件IO操作中也是有用的。

那么是如何做到的呢？

  1. 首先，对于读操作，使用dispatch_async，所以读操作是异步的。
  2. 对于写操作，使用dispatch_barrier_async，保证当有一条线程在执行这个任务的时候，绝不允许queue中有其他线程在执行其他任务。

示意图如下：

栅栏.png

注意：这个dispatch_barrier_async函数传入的并发队列必须是自己手动通过dispatch_queue_cretate创建的。如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果。

dispatch_barrier_async和dispatch_barrier_sync的区别

相同点：使用dispatch_barrier_async和dispatch_barrier_sync，都保证当有一条线程在执行这个任务的时候，绝不允许queue中有其他线程在执行其他任务。

不同点：dispatch_barrier_async是异步栅栏，会开启新线程（如上打印所示），dispatch_barrier_sync是同步栅栏，不会开启新线程。

如果把上面代码改成：

dispatch_barrier_sync(self.queue, ^{
    [self write];
});

打印如下：

2021-06-01 16:20:51.992188+0800 -[read]--线程：{number = 4, name = (null)}
2021-06-01 16:20:51.992205+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:20:51.992208+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:20:52.993967+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:20:53.995608+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:20:54.996736+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:20:56.001371+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:20:56.001470+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:20:56.001486+0800 -[read]--线程：{number = 4, name = (null)}
2021-06-01 16:20:57.002200+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:20:58.003470+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:20:59.004165+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:00.005287+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:21:00.005287+0800 -[read]--线程：{number = 4, name = (null)}
2021-06-01 16:21:00.005287+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:21:01.005890+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:02.006747+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:03.008123+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:04.009767+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:21:04.009768+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:21:04.009781+0800 -[read]--线程：{number = 3, name = (null)}
2021-06-01 16:21:05.010196+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:06.010984+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:07.011930+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:08.014189+0800 -[read]--线程：{number = 5, name = (null)}
2021-06-01 16:21:08.014189+0800 -[read]--线程：{number = 6, name = (null)}
2021-06-01 16:21:08.014190+0800 -[read]--线程：{number = 4, name = (null)}
2021-06-01 16:21:09.015798+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:10.016433+0800 -[write]--线程：{number = 1, name = main}
2021-06-01 16:21:11.017820+0800 -[write]--线程：{number = 1, name = main}

可以发现，使用dispatch_barrier_sync没有开启新线程，写操作在当前线程（主线程）执行。

Demo地址：加锁方案2

你可能感兴趣的:(iOS-多线程3-加锁方案2)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 30天风格练习-DAY2 黄希夷
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 向内而求 陈陈_19b4
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • 开心 蒋泳频
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 今日联对0306 诗图佳得
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 2022-07-08 保利学府里李楚怡1307022
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
  • Java序列化进阶篇 g21121 java序列化
            1.transient         类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。
  • escape()、encodeURI()、encodeURIComponent()区别详解 aigo JavaScriptWeb
    原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html   JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。 下面简单介绍一下它们的区别 1 escape()函
  • ArcgisEngine实现对地图的放大、缩小和平移 Cb123456 添加矢量数据对地图的放大、缩小和平移Engine
    ArcgisEngine实现对地图的放大、缩小和平移:  个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧.  具体实现: 一、引入命名空间    using ESRI.ArcGIS.Geometry;    using ESRI.ArcGIS.Controls; 二、代码实现.
  • Java集合框架概述 天子之骄 Java集合框架概述
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • 旗正4.0页面跳转传值问题 何必如此 javajsp
    跳转和成功提示 a)        成功字段非空forward 成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
  • 全网唯一:移动互联网服务器端开发课程 cocos2d-x小菜 web开发移动开发移动端开发移动互联程序员
        移动互联网时代来了！     App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
  • Log4J通用配置|注意问题 笔记 7454103 DAOapachetomcatlog4jWeb
    关于日志的等级 那些去 百度就知道了！ 这几天 要搭个新框架  配置了 日志 记下来 ！做个备忘！ #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~! log4j.rootLogger=INFO,allLog # DAO层 log记录到dao.log 控制台 和 总日志文件 log4j.logger.DAO=INFO,dao,C
  • SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager darkranger sqlcwindowsSQL ServerXP
    当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 发现需要启动客户端协议 : TCP/IP  需要打开 SQL Server Configuration Manager... 却发现无法打开 SQL Server Configuration Manager..?? 解决方法:  C:\WINDOWS\system32目录搜索framedyn.
  • [置顶] 做有中国特色的程序员 aijuans 程序员
    从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
  • document.domain 跨域问题 avords document
    document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com");
  • 关于管理软件的一些思考 houxinyou 管理
    工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 做为管理软件,就像现在讲究MVC这
  • NoSQL数据库之Redis数据库管理(String类型和hash类型) bijian1013 redis数据库NoSQL
    一.Redis的数据类型 1.String类型及操作         String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。         Set方法：设置key对应的值为string类型的value
  • Tomcat 一些技巧 征客丶 javatomcatdos
    以下操作都是在windows 环境下 一、Tomcat 启动时配置 JAVA_HOME 在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 set JAVA_HOME=JAVA 安装目录 set JRE_HOME=JAVA 安装目录/jre 即可； 二、查看Tomcat 版本 在 tomcat 安装目
  • 【Spark七十二】Spark的日志配置 bit1129 spark
    在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console   在Spark的conf目录下，把log4j.properties.template修改为log4j.p
  • Haskell版冒泡排序 bookjovi 冒泡排序haskell
    面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。     sort [] = [] sort [x] = [x] sort (x:x1:xs) | x>x1 = x1:so
  • java 路径 配置文件读取 bro_feng java
    这几天做一个项目，关于路径做如下笔记，有需要供参考。 取工程内的文件，一般都要用相对路径，这个自然不用多说。 在src统计目录建配置文件目录res,在res中放入配置文件。 读取文件使用方式： 1. MyTest.class.getResourceAsStream("/res/xx.properties") 2. properties.load(MyTest.
  • 读《研磨设计模式》-代码笔记-简单工厂模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 个人理解：简单工厂模式就是IOC; * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了 */ interface IProduct {
  • SVN与JIRA的关联 chenyu19891124 SVN
    SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤： 一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务 二、装好JIRA，自己用是jira-4.3.4破解版 三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
  • JWFDv0.96 最新设计思路 comsci 数据结构算法工作企业应用公告
                       随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
  • vi 保存复制内容格式粘贴 daizj vi粘贴复制保存原格式不变形
        vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？ 答案是肯定的，vi有一个很强大的命令可以实现此功能 。     在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
  • shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法 dongwei_6688 shell脚本
    出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致 解决办法： 1. 比如文件名为myshell.sh，vim myshell.sh 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
  • 高一上学期难记忆单词 dcj3sjt126com wordenglish
    honest 诚实的；正直的 argue 争论 classical 古典的 hammer 锤子 share  分享；共有 sorrow 悲哀；悲痛 adventure 冒险 error 错误；差错 closet 壁橱；储藏室 pronounce 发音；宣告 repeat 重做；重复 majority 大多数；大半   native 本国的，本地的，本国
  • hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性 frankco POJOhibernate查询DTO
          DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。       简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。         有时候我们需要查询返回DTO对象，因为DTO
  • Partition List hcx2013 partition
    Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of th
  • Spring MVC测试框架详解——客户端测试 jinnianshilongnian
    上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
  • 关于推荐个人观点 liyonghui160com 推荐系统关于推荐个人观点
        回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】     第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
  • 不间断旋转的动画 pangyulei 动画
    CABasicAnimation* rotationAnimation; rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotationAnimation.toValue = [NSNumber numberWithFloat: M
  • 自定义annotation sha1064616837 javaenumannotationreflect
    对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。 下面这个例子 主要用到了 1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 2.简单的反射 3.枚举
  • Spring 源码 up2pu spring
    1.Spring源代码 https://github.com/SpringSource/spring-framework/branches/3.2.x 注：兼容svn检出 2.运行脚本 import-into-eclipse.bat 注：需要设置JAVA_HOME为jdk 1.7 build.gradle compileJava { sourceCompatibilit
  • 利用word分词来计算文本相似度 yangshangchuan wordword分词文本相似度余弦相似度简单共有词
    word分词提供了多种文本相似度计算方式： 方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 实现类：org.apdplat.word.analysis.CosineTextSimilarity 用法如下： String text1 = "我爱购物"; String text2 = "我爱读书"; String text3 =
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他