C#管理大量耗时的线程,内存占用严重
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C#管理大量耗时的线程,内存占用严重相关的知识,希望对你有一定的参考价值。
我水平有限,在socket方面不在行,一直让我对socket没信心的是两个方面,
第一:socket异常时有些捕获不到,就是没法准确判断连接是否已经断开;
第二:重点,就是每个客户端连接过来的时候都需要开辟一个新的线程去处理客户发来的消息,如果客户过多势必导致线程数量不断增加,内存也会飙升,怎么有效的管理这些线程,让内存更加稳定呢, 或者说就socket这块大量用户连接的时候有没有更好的处理方法, 线程池不适合用来做耗时的任务,大家懂的
1)你一定看到过System.Net.Socket类中有很多BeginXXX / EndXXX的方法,例如Socket.BeginReceiveFrom和Socket.EndReceiveFrom,这些函数统称为异步函数。而异步函数操作的基础恰恰就是线程池。对Socket通信而言,微软提供的异步操作正是利用线程池中I/O线程,目的就是为了提高Socket I/O性能并简化内存管理的!
2)如果对异步操作感到头晕,在处理Socket操作时可以使用“显式线程”方法,即按以下方法启动处理线程:
System.Thread t = new System.Thread(你的处理函数);
t.IsBackground = true; //这个设置尤其重要!!!!!
t.Start();
一定要注意将线程设置为后台线程!
3)你一定知道系统每次启动线程和销毁线程时都会导致很大的开销。当你的程序频繁的启动、销毁线程,必然会导致程序很“卡”;正是由于这个缘故,微软才搞了一个“线程池”。因为线程中的线程都是“启动完毕的”(这样表述虽不确切,但没有错),一旦你将异步处理函数“挂接”的线程池中的空闲线程上即可以执行你要的操作。而且,额外的好处是你根本不用去管理线程池中的线程(真正的“零”管理)
4)处理“耗时的操作”特别是涉及诸如Socket I/O 耗时操作,最佳的处理方法是利用后台线程(如果需要,同时配合以自定义事件event),这是增加用户体验不二法门哦~~追问
就是说 在简单的Socket编程中,用户进入跟处理用户信息全部用异步来操作是吗,不需要用“显式线程”来处理么? 这样做仅仅是为了让系统自动回收垃圾吗 还是有别的好处?
另外在别的地方看到异步处理是不是有个数限制,比如能异步接收64个客户进入,
你说的 "用户进入跟处理用户信息"中的用户信息是通过Socket传递的吗?如果是,在异步回调中处理 。总之,涉及到Socket的操作均采用异步处理或后台线程处理。
曾经编写一个Socket UDP程序,同时处理1000多个客户端,双核CPU,2G内存。运行过程中CPU平均占用率不超过12%
我一直是用的isBackGround的, 可能内存飙升不是线程的问题吧,
追答嗯,应该不是线程的问题。导致内存使用飙升的根本原因肯定是处理过程中生成大量的对象并没有释放。这里说的“释放”与“垃圾回收”不是同一个概念。“释放”是指定一个对象引用的“释放”。但垃圾回收规则,只有对一个对象的所有引用都释放了才能进行垃圾回收。反过来说,只有对象存在引用,就不会做垃圾回收。
参考技术A Windows下参考完全端口,也叫iocp;Linux下参见Epoll 参考技术B你的问题涉及很多方面。帮你清理一下,
socket 的追踪问题,没法准确判断连接是否已经断开,今天技术问题很容易解决。
多线程问题,每个客户端连接过来的时候都需要开辟一个新的线程去处理客户发来的消息。
耗时的任务, 感觉关键在于耗时的任务,因为耗时的线程确实会很快消耗掉所有的线程池。
首先,耗时是什么造成的,如果是硬盘读写,能否用cache解决?如果是网络问题,能否call back? 如果是数据库问题,能否用cluster?如果是CPU问题,能否采用web farm?
OC - 浅谈内存管理
今天看到一篇不错的文章关于OC内存管理的,转载一下与你共享
概述
我们知道在程序运行过程中要创建大量的对象,和其他高级语言类似,在ObjC中对象时存储在堆中的,系统并不会自动释放堆中的内存(注意基本类型是由系统自己管理的,放在栈上)。如果一个对象创建并使用后没有得到及时释放那么就会占用大量内存。其他高级语言如C#、Java都是通过垃圾回收来(GC)解决这个问题的,但在OjbC中并没有类似的垃圾回收机制,因此它的内存管理就需要由开发人员手动维护。今天将着重介绍ObjC内存管理:
1 引用计数器
2 属性参数
3 自动释放池
引用计数器
在Xcode4.2及之后的版本中由于引入了ARC(Automatic Reference Counting)机制,程序编译时Xcode可以自动给你的代码添加内存释放代码,如果编写手动释放代码Xcode会报错,因此在今天的内容中如果你使用的是Xcode4.2之后的版本(相信现在大部分朋友用的版本都比这个要高),必须手动关闭ARC,这样才有助于你理解ObjC的内存回收机制。
ObjC中的内存管理机制跟C语言中指针的内容是同样重要的,要开发一个程序并不难,但是优秀的程序则更测重于内存管理,它们往往占用内存更少,运行更加流畅。虽然在新版Xcode引入了ARC,但是很多时候它并不能完全解决你的问题。在Xcode中关闭ARC:项目属性—Build Settings--搜索“garbage”找到Objective-C Automatic Reference Counting设置为No即可。
内存管理原理
我们都知道在C#、Java中都有GC在自动管理内存,当我们实例化一个对象之后通常会有一个变量来引用这个对象(变量中存储对象地址),当这个引用变量不再使用之后(也就是不再引用这个对象)此时GC就会自动回收这个对象,简单的说就是:当一个对象没有任何变量引用的时候就会被回收。
例如下面的C#代码片段
using System;
namespace GC
{
class Program
{
private static void Test()
{
object o=new object();
}
static void Main(string[] args)
{
Test();
}
}
}
上面是一段C#代码,在Test()方法中,通过new Object()创建了一个对象,o是一个对象的引用(存储了对象的地址),它是一个局部变量,作用范围就是Test()方法内部。
?
当执行完Test()方法之后o就会被释放,此时由于没有变量在引用new Object()这个对象,因此GC会自动回收这个对象所占用的空间。
但是在ObjC中没有垃圾回收机制,那么ObjC中内存又是如何管理的呢?其实在ObjC中内存的管理是依赖对象引用计数器来进行的:在ObjC中每个对象内部都有一个与之对应的整数(retainCount),叫“引用计数器”,当一个对象在创建之后它的引用计数器为1,当调用这个对象的alloc、retain、new、copy方法之后引用计数器自动在原来的基础上加1(ObjC中调用一个对象的方法就是给这个对象发送一个消息),当调用这个对象的release方法之后它的引用计数器减1,如果一个对象的引用计数器为0,则系统会自动调用这个对象的dealloc方法来销毁这个对象。
下面通过一个简单的例子看一下引用计数器的知识:
Person.h
//
// Person.h
// MemoryManage
//
// Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Person : NSObject
#pragma mark - 属性
@property (nonatomic,copy) NSString *name;
@property (nonatomic,assign) int age;
@end
Person.m
//
// Person.m
// MemoryManage
//
// Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import "Person.h"
@implementation Person
#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法,在这个方法中通常进行对象释放操作
-(void)dealloc{
NSLog(@"Invoke Person‘s dealloc method.");
[super dealloc];//注意最后一定要调用父类的dealloc方法(两个目的:一是父类可能有其他引用对象需要释放;二是:当前对象真正的释放操作是在super的dealloc中完成的)
}
@end
main.m
//
// main.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "Person.h"
void Test1(){
Person *p=[[Person alloc]init]; //调用alloc,引用计数器+1
[email protected]"Kenshin";
p.age=28;
NSLog(@"retainCount=%lu",[p retainCount]);
//结果:retainCount=1
[p release];
//结果:Invoke Person‘s dealloc method.
//上面调用过release方法,p指向的对象就会被销毁,但是此时变量p中还存放着Person对象的地址,
//如果不设置p=nil,则p就是一个野指针,它指向的内存已经不属于这个程序,因此是很危险的
p=nil;
//如果不设置p=nil,此时如果再调用对象release会报错,但是如果此时p已经是空指针了,
//则在ObjC中给空指针发送消息是不会报错的
[p release];
}
void Test2(){
Person *p=[[Person alloc]init];
[email protected]"Kenshin";
p.age=28;
NSLog(@"retainCount=%lu",[p retainCount]);
//结果:retainCount=1
[p retain];//引用计数器+1
NSLog(@"retainCount=%lu",[p retainCount]);
//结果:retainCount=2
[p release];//调用1次release引用计数器-1
NSLog(@"retainCount=%lu",[p retainCount]);
//结果:retainCount=1
[p release];
//结果:Invoke Person‘s dealloc method.
p=nil;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
Test1();
}
return 0;
}
在上面的代码中我们可以通过dealloc方法来查看是否一个对象已经被回收,如果没有被回收则有可能造成内存泄露。如果一个对象被释放之后,那么最后引用它的变量我们手动设置为nil,否则可能造成野指针错误,而且需要注意在ObjC中给空对象发送消息是不会引起错误的。
野指针错误形式在Xcode中通常表现为:Thread 1:EXC_BAD_ACCESS(code=EXC_I386_GPFLT)错误。因为你访问了一块已经不属于你的内存。
内存释放的原则
手动管理内存有时候并不容易,因为对象的引用有时候是错综复杂的,对象之间可能互相交叉引用,此时需要遵循一个法则:谁创建,谁释放。
假设现在有一个人员Person类,每个Person可能会购买一辆汽车Car,通常情况下购买汽车这个活动我们可能会单独抽取到一个方法中,同时买车的过程中我们可能会多看几辆来最终确定理想的车,现在我们的代码如下:
Car.h
//
// Car.h
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Car : NSObject
#pragma mark - 属性
#pragma mark 车牌号
@property (nonatomic,copy) NSString *no;
#pragma mark - 公共方法
#pragma mark 运行方法
-(void)run;
@end
Car.m
//
// Car.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import "Car.h"
@implementation Car
#pragma mark - 公共方法
#pragma mark 运行方法
-(void)run{
NSLog(@"Car(%@) run.",self.no);
}
#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{
NSLog(@"Invoke Car(%@) dealloc method.",self.no);
[super dealloc];
}
@end
Person.h
//
// Person.h
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
@class Car;
@interface Person : NSObject{
Car *_car;
}
#pragma mark - 属性
#pragma mark 姓名
@property (nonatomic,copy) NSString *name;
#pragma mark - 公共方法
#pragma mark Car属性的set方法
-(void)setCar:(Car *)car;
#pragma mark Car属性的get方法
-(Car *)car;
@end
Person.m
//
// Person.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import "Person.h"
#import "Car.h"
@implementation Person
#pragma mark - 公共方法
#pragma mark Car属性的set方法
-(void)setCar:(Car *)car{
if (_car!=car) { //首先判断要赋值的变量和当前成员变量是不是同一个变量
[_car release]; //释放之前的对象
_car=[car retain];//赋值时重新retain
}
}
#pragma mark Car属性的get方法
-(Car *)car{
return _car;
}
#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{
NSLog(@"Invoke Person(%@) dealloc method.",self.name);
[_car release];//在此释放对象,即使没有赋值过由于空指针也不会出错
[super dealloc];
}
@end
main.m
//
// main.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Car.h"
void getCar(Person *p){
Car *car1=[[Car alloc]init];
[email protected]"888888";
p.car=car1;
NSLog(@"retainCount(p)=%lu",[p retainCount]);
Car *car2=[[Car alloc]init];
[email protected]"666666";
[car1 release];
car1=nil;
[car2 release];
car2=nil;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p=[[Person alloc]init];
[email protected]"Kenshin";
getCar(p);
[p.car run];
[p release];
p=nil;
}
return 0;
}
程序运行结果:
?
从运行结果来看创建的三个对象p、car1、car2都被回收了,而且[p.car run]也能顺利运行,已经达到了我们的需求。但是这里需要重点解释一下setCar方法的实现,setCar方法中为什么没有写成如下形式:
-(void)setCar:(Car *)car{
_car=car;
}
前面在我们说到属性的定义时不是都采用的这种方式吗?
根据前面说到的内存释放原则,getCar方法完全符合,在这个方法中定义的两个对象car1、car2也都是在这个方法中释放的,包括main函数中的p对象也是在main函数中定义和释放的。但是如果发现调用完getCar方法之后紧接着调用了汽车的run方法,当然这在程序设计和开发过程中应该是再普通不过的设计了。如果setCar写成“_car=car”的形式,当调用完getCar方法后,人员的car属性被释放了,此时调用run方法是会报错的(大家自己可以试试)。但是如下的方式却不会有问题:
-(void)setCar:(Car *)car{
if (_car!=car) { //首先判断要赋值的变量和当前成员变量是不是同一个变量
[_car release]; //释放之前的对象
_car=[car retain];//赋值时重新retain
}
}
因为在这个方法中我们通过[car retain]保证每次属性赋值的时候对象引用计数器+1,这样一来调用过getCar方法可以保证人员的car属性不会被释放,其次为了保证上一次的赋值对象(car1)能够正常释放,我们在赋新值之前对原有的值进行release操作。最后在Person的dealloc方法中对_car进行一次release操作(因为setCar中做了一次retain操作)保证_car能正常回收。
属性参数
像上面这样编写setCar方法的情况是比较多的,那么如何使用@property进行自动实现呢?答案就是使用属性参数,例如上面car属性的setter方法,可以通过@property定义如下:
@property (nonatomic,retain) Car *car;
你会发现此刻我们不必手动实现car的getter、setter方法程序仍然没有内存泄露。其实大家也应该都已经看到前面Person的name属性定义的时候我们同样加上了(nonatomic,copy)参数,这些参数到底是什么意思呢?
?
@property的参数分为三类,也就是说参数最多可以有三个,中间用逗号分隔,每类参数可以从上表三类参数中人选一个。如果不进行设置或者只设置其中一类参数,程序会使用三类中的各个默认参数,默认参数:(atomic,readwrite,assign)
一般情况下如果在多线程开发中一个属性可能会被两个及两个以上的线程同时访问,此时可以考虑atomic属性,否则建议使用nonatomic,不加锁,效率较高;readwirte方法会生成getter、setter两个方法,如果使用readonly则只生成getter方法;关于set方法处理需要特别说明,假设我们定义一个属性a,这里列出三种方式的生成代码:
assign,用于基本数据类型
-(void)setA:(int)a{
_a=a;
}
retain,通常用于非字符串对象
-(void)setA:(Car *)a{
if(_a!=a){
[_a release];
_a=[a retain];
}
}
copy,通常用于字符串对象、block、NSArray、NSDictionary
-(void)setA:(NSString *)a{
if(_a!=a){
[_a release];
_a=[a copy];
}
}
备注:本文基于MRC进行介绍,ARC下的情况不同,请参阅其他文章,例如ARC下基本数据类型默认的属性参数为(atomic,readwrite,assign),对象类型默认的属性参数为(atomic,readwrite,strong)
自动释放池
在ObjC中也有一种内存自动释放的机制叫做“自动引用计数”(或“自动释放池”),与C#、Java不同的是,这只是一种半自动的机制,有些操作还是需要我们手动设置的。自动内存释放使用@autoreleasepool关键字声明一个代码块,如果一个对象在初始化时调用了autorelase方法,那么当代码块执行完之后,在块中调用过autorelease方法的对象都会自动调用一次release方法。这样一来就起到了自动释放的作用,同时对象的销毁过程也得到了延迟(统一调用release方法)。看下面的代码:
Person.h
//
// Person.h
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface Person : NSObject
#pragma mark - 属性
#pragma mark 姓名
@property (nonatomic,copy) NSString *name;
#pragma mark - 公共方法
#pragma mark 带参数的构造函数
-(Person *)initWithName:(NSString *)name;
#pragma mark 取得一个对象(静态方法)
+(Person *)personWithName:(NSString *)name;
@end
Person.m
//
// Person.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import "Person.h"
@implementation Person
#pragma mark - 公共方法
#pragma mark 带参数的构造函数
-(Person *)initWithName:(NSString *)name{
if(self=[super init]){
self.name=name;
}
return self;
}
#pragma mark 取得一个对象(静态方法)
+(Person *)personWithName:(NSString *)name{
Person *p=[[[Person alloc]initWithName:name] autorelease];//注意这里调用了autorelease
return p;
}
#pragma mark - 覆盖方法
#pragma mark 重写dealloc方法
-(void)dealloc{
NSLog(@"Invoke Person(%@) dealloc method.",self.name);
[super dealloc];
}
@end
main.m
//
// main.m
// MemoryManage
//
// Created by Kenshin Cui on 14-2-15.
// Copyright (c) 2014年 Kenshin Cui. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person1=[[Person alloc]init];
[person1 autorelease];//调用了autorelease方法后面就不需要手动调用release方法了
[email protected]"Kenshin";//由于autorelease是延迟释放,所以这里仍然可以使用person1
Person *person2=[[[Person alloc]initWithName:@"Kaoru"] autorelease];//调用了autorelease方法
Person *person3=[Person personWithName:@"rosa"];//内部已经调用了autorelease,所以不需要手动释放,这也符合内存管理原则,因为这里并没有alloc所以不需要release或者autorelease
Person *person4=[Person personWithName:@"jack"];
[person4 retain];
}
/*结果:
Invoke Person(rosa) dealloc method.
Invoke Person(Kaoru) dealloc method.
Invoke Person(Kenshin) dealloc method.
*/
return 0;
}
当上面@autoreleaespool代码块执行完之后,三个对象都得到了释放,但是person4并没有释放,原因很简单,由于我们手动retain了一次,当自动释放池释放后调用四个对的release方法,当调用完person4的release之后它的引用计数器为1,所有它并没有释放(这是一个反例,会造成内存泄露);autorelase方法将一个对象的内存释放延迟到了自动释放池销毁的时候,因此上面person1,调用完autorelase之后它还存在,因此给name赋值不会有任何问题;在ObjC中通常如果一个静态方法返回一个对象本身的话,在静态方法中我们需要调用autorelease方法,因为按照内存释放原则,在外部使用时不会进行alloc操作也就不需要再调用release或者autorelase,所以这个操作需要放到静态方法内部完成。
对于自动内存释放简单总结一下:
1 autorelease方法不会改变对象的引用计数器,只是将这个对象放到自动释放池中;
2 自动释放池实质是当自动释放池销毁后调用对象的release方法,不一定就能销毁对象(例如如果一个对象的引用计数器>1则此时就无法销毁);
3 由于自动释放池最后统一销毁对象,因此如果一个操作比较占用内存(对象比较多或者对象占用资源比较多),最好不要放到自动释放池或者考虑放到多个自动释放池;
4 ObjC中类库中的静态方法一般都不需要手动释放,内部已经调用了autorelease方法;
转载来自崔江涛(KenshinCui)
相关链接:http://www.cnblogs.com/kenshincui/p/3870325.html
以上是关于C#管理大量耗时的线程,内存占用严重的主要内容,如果未能解决你的问题,请参考以下文章
C#编写的程序 使用Webbrowser控件,占用大量内存?