ifgyong / demo Goto Github PK

typealias FnClo = (Int) -> (Int,Int)
func getFns() -> (FnClo,FnClo) {
    var num1 = 0
    var num2 = 0
    func plus(_ i:Int) -> (Int,Int){
        num1 += i
        num2 += i << 1
        return (num1,num2)
    }
    func mnus(_ i:Int) -> (Int,Int){
        num1 -= i
        num2 -= i << 1
        return (num1,num2)
    }
    return (plus,mnus)
}

let (p,m) = getFns()
print(p(5))
print(m(4)) 
print(p(3))
print(m(2))

class Person {
	var age = 9
}
typealias Clo = (Int) -> Int
func getFunc () -> Clo {
	var p = Person()
    func plus(_ v:Int) ->Int{
		p.age += v;
        return p.age
    }
    return plus
}
var f = getFunc() //
f(3)

@interface ViewController2 ()
@property (nonatomic,strong) Block* block;

@property(nonatomic,copy) NSString *name;
@property(nonatomic,assign) int age;
@end

@implementation ViewController2

- (void)viewDidLoad {
    [super viewDidLoad];
	self.block=[Block new];
//	[self testBlock1];/// 会内存泄露
//	[self testBlock5];
	[self test5];
}
/// 会内存泄露
 - (void )testBlock1{
	 [self.block addBlock:^{
		 NSLog(@"addblock test1");
		 self.view.backgroundColor = UIColor.blueColor;
	 }];
 }
/// 不会内存泄露 单是会延迟释放，gcd 引用block，block中有self，等gcd执行完成，释放掉block，则self可以释放掉了
 - (void)testBlock2{
	 [self.block addBlockSecond:^{
		 NSLog(@"addBlockSecond test2");
		 self.view.backgroundColor = UIColor.blueColor;
	 }];
 }
 - (void)testBlock3{
	 [[Block new] addBlockSecond:^{
		 NSLog(@"[Block new] addBlockSecond test3");
		 self.view.backgroundColor = UIColor.redColor;
	 }];
 }
/// 紧紧当执行到strong的时候监测 weakself是否已经释放，加入没有释放则进行引用，那么久block中执行过程中则不会释放掉，block执行完成，则释放掉
-(void)testBlock5{
	__weak typeof(self) __weakSelf = self;
	[self.block addBlockSecond:^{
		NSLog(@"addBlockSecond test5");

		ViewController2 *strongSelf = __weakSelf;
		NSLog(@"addBlockSecond test5 %@",strongSelf);
		
		
		 strongSelf.name=@"name";
		 NSLog(@"addBlockSecond test5 - 2%@",strongSelf);

		 strongSelf.age = 10;
		 NSLog(@"addBlockSecond test5 - 3%@",strongSelf);

	}];
 }
-(void)dealloc{
	NSLog(@"dealloc vc2");
}



- (void)action{
	NSLog(@"3");
}
/// 输出 1 2  没有3，原因是异步串行队列，在子线程中执行，子线程执行完毕，销毁，导致定时器2s后的函数没执行，runloop已经结束。dispatch_async
/// 同步的话输出是 1 2 3 ，原因是同步队列在主线程执行，主线程runloop 不会销毁，定时器则按时执行函数。dispatch_sync
///
- (void)test{
	dispatch_queue_t queue = dispatch_queue_create("123", DISPATCH_QUEUE_SERIAL);
	dispatch_async(queue, ^{
		NSLog(@"1 %@",[NSThread currentThread]);
		[self performSelector:@selector(action) withObject:nil afterDelay:2.0];
		NSLog(@"2");
	});
}
/// 异步队列 for 循环找那个生成多个线程执行函数，最后被栅栏函数拦截掉
/// 当异步队列是全局队列的话则拦截失败，系统设定
- (void)test2{
	dispatch_queue_t queue = dispatch_queue_create("123", DISPATCH_QUEUE_CONCURRENT);
	queue = dispatch_get_global_queue(0, 0);
	for (int i = 0; i < 100; i ++) {
		dispatch_async(queue, ^{
			sleep(rand()%10/10.0);
			NSLog(@"%d %@",i,[NSThread currentThread]);
		});
	}
	
	dispatch_barrier_async(queue, ^{
		NSLog(@"100 %@",[NSThread currentThread]);
	});

	dispatch_async(queue, ^{
		NSLog(@"101 %@",[NSThread currentThread]);
	});
}
/// 会读写失败 原因是 多线程操作数据属于读写需要加锁，否则数据扩容的时候再去写入和读会报错
/// error for object 0x600001a8c4e0: pointer being freed was not allocated
/// 只需要将lock打开加锁即可。
- (void)test4{
	NSMutableArray *ret =[NSMutableArray new];
//	NSLock *lock=[NSLock new];
	dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
	for (int i = 0;  i<100; i ++) {
		dispatch_async(queue, ^{
			[ret addObject:[NSObject new]];
//			[lock lock];
//			[ret addObject:[NSObject new]];
//			[lock unlock];
		});
	}
}
- (void)test5{
	Person *p=[Person new];
	
		dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
		for (int i = 0;  i<100; i ++) {
			dispatch_async(queue, ^{
				NSString *name = [NSString stringWithFormat:@"stringWithFormatstringWithFormat123 %d",i];
				NSLog(@" %p",name);
				/// 字符串放在 常量区 不会释放
				p.name=name;
				/// 多线程中 [Person new] 有可能执行完毕多个线程同时执行 release，导致崩溃。
				p.next=[Person new];
			});
		}
}
@end



@interface Block : NSObject
@property (nonatomic,strong) dispatch_block_t block;
-(void)addBlock:(dispatch_block_t)block;
-(void)addBlockSecond:(dispatch_block_t)block;
@end

@implementation Block
// self->block->self  导致了 循环引用
-(void)addBlock:(dispatch_block_t)block{
	self.block = block;
	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
		if (self.block) {
			self.block();
		}
	});
}
// 没有形成循环链 不会内存泄露
-(void)addBlockSecond:(dispatch_block_t)block{
	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
		if (block) {
			block();
		}
	});
}
- (void)dealloc
{
	NSLog(@"dealloc Block ");
}




@end