1.什么是死锁，怎么解决死锁
〈1〉互斥条件。即某个资源在一段时间内只能由一个进程占有，不能同时被两个或两个以上的进程占有。这种独占资源如CD-ROM驱动器，打印机等等，必须在占有该资源的进程主动释放它之后，其它进程才能占有该资源。这是由资源本身的属性所决定的。如独木桥就是一种独占资源，两方的人不能同时过桥。
〈2〉不可抢占条件。进程所获得的资源在未使用完毕之前，资源申请者不能强行地从资源占有者手中夺取资源，而只能由该资源的占有者进程自行释放。如过独木桥的人不能强迫对方后退，也不能非法地将对方推下桥，必须是桥上的人自己过桥后空出桥面（即主动释放占有资源），对方的人才能过桥。
〈3〉占有且申请条件。进程至少已经占有一个资源，但又申请新的资源；由于该资源已被另外进程占有，此时该进程阻塞；但是，它在等待新资源之时，仍继续占用已占有的资源。还以过独木桥为例，甲乙两人在桥上相遇。甲走过一段桥面（即占有了一些资源），还需要走其余的桥面（申请新的资源），但那部分桥面被乙占有（乙走过一段桥面）。甲过不去，前进不能，又不后退；乙也处于同样的状况。
〈4〉循环等待条件。存在一个进程等待序列{P1，P2，...，Pn}，其中P1等待P2所占有的某一资源，P2等待P3所占有的某一源，......，而Pn等待P1所占有的的某一资源，形成一个进程循环等待环。就像前面的过独木桥问题，甲等待乙占有的桥面，而乙又等待甲占有的桥面，从而彼此循环等待。
上面我们提到的这四个条件在死锁时会同时发生。也就是说，只要有一个必要条件不满足，则死锁就可以排除。
前面介绍了死锁发生时的四个必要条件，只要破坏这四个必要条件中的任意一个条件，死锁就不会发生。这就为我们解决死锁问题提供了可能。一般地，解决死锁的方法分为死锁的预防，避免，检测与恢复三种（注意：死锁的检测与恢复是一个方法）。我们将在下面分别加以介绍。
死锁的预防是保证系统不进入死锁状态的一种策略。它的基本思想是要求进程申请资源时遵循某种协议，从而打破产生死锁的四个必要条件中的一个或几个，保证系统不会进入死锁状态。
〈1〉打破互斥条件。即允许进程同时访问某些资源。但是，有的资源是不允许被同时访问的，像打印机等等，这是由资源本身的属性所决定的。所以，这种办法并无实用价值。
〈2〉打破不可抢占条件。即允许进程强行从占有者那里夺取某些资源。就是说，当一个进程已占有了某些资源，它又申请新的资源，但不能立即被满足时，它必须释放所占有的全部资源，以后再重新申请。它所释放的资源可以分配给其它进程。这就相当于该进程占有的资源被隐蔽地强占了。这种预防死锁的方法实现起来困难，会降低系统性能。
〈3〉打破占有且申请条件。可以实行资源预先分配策略。即进程在运行前一次性地向系统申请它所需要的全部资源。如果某个进程所需的全部资源得不到满足，则不分配任何资源，此进程暂不运行。只有当系统能够满足当前进程的全部资源需求时，才一次性地将所申请的资源全部分配给该进程。由于运行的进程已占有了它所需的全部资源，所以不会发生占有资源又申请资源的现象，因此不会发生死锁。但是，这种策略也有如下缺点：
（1）在许多情况下，一个进程在执行之前不可能知道它所需要的全部资源。这是由于进程在执行时是动态的，不可预测的；
（2）资源利用率低。无论所分资源何时用到，一个进程只有在占有所需的全部资源后才能执行。即使有些资源最后才被该进程用到一次，但该进程在生存期间却一直占有它们，造成长期占着不用的状况。这显然是一种极大的资源浪费；
（3）降低了进程的并发性。因为资源有限，又加上存在浪费，能分配到所需全部资源的进程个数就必然少了。
（4）打破循环等待条件，实行资源有序分配策略。采用这种策略，即把资源事先分类编号，按号分配，使进程在申请，占用资源时不会形成环路。所有进程对资源的请求必须严格按资源序号递增的顺序提出。进程占用了小号资源，才能申请大号资源，就不会产生环路，从而预防了死锁。这种策略与前面的策略相比，资源的利用率和系统吞吐量都有很大提高，但是也存在以下缺点：
（1）限制了进程对资源的请求，同时给系统中所有资源合理编号也是件困难事，并增加了系统开销；
（2）为了遵循按编号申请的次序，暂不使用的资源也需要提前申请，从而增加了进程对资源的占用时间。
2.线程同步有几种实现方法,都是什么？
临界区、互斥区、事件、信号量四种方式
临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）的区别
1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。
2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享
3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目
4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作
3.C++以及OC单例
#include <iostream>
#include <memory>
using namespace std;
//最简单的
class Singleton
{
public:
static Singleton *Instance()
{
if (0==_instance) {
_instance=new Singleton;
}
return _instance;
}
protected:
Singleton(void)
{
}
virtual ~Singleton(void)
{
}
static Singleton * _instance;
};
//释放内存
class Singleton1 {
public:
static Singleton1 *Instance1()
{
if (0==_instance1.get()) {
_instance1.reset(new Singleton1);
}
return _instance1.get();
}
protected:
Singleton1(void)
{
cout<<"Creat Singleton"<<endl;
}
virtual ~Singleton1(void)
{
cout<<"Destory Singleton"<<endl;
}
friend class auto_ptr<Singleton1>;
static auto_ptr<Singleton1>_instance1;
};
#import "File.h"
@implementation File
//定义一个静态实例，并初始化为nill
static File *sharefile=nil;
+(File*)shareFile
{
@synchronized(self)//线程保护
{
//如果实例为nil，则创建该实例
if (sharefile==nil) {
sharefile=[[self alloc]init];
}
}
return sharefile;
}
+(id)allocWithZone:(NSZone *)zone
{
NSLog(@"nil %p");
@synchronized(self){
if (sharefile==nil) {
sharefile=[super allocWithZone:zone];
return sharefile;
}
}
return sharefile;
}
//覆盖allocWirhZone方法
-(id)copyWithZone:(NSZone*)zone
{
return self;//实现copy协议，返回本身
}
-(id)retain
{
return self;//返回本身
}
-(NSInteger)retainCount
{
return UINT_MAX;//返回无符号整形范围最大值
}
-(oneway void)release
{
//什么都不做
}
-(id)autorelease
{
return self;//返回本身
}
@end
4.游乐场有3条游客入场通道，但是最多只能容纳150人。请使用多线程的方式实现这个场景！
//.h
#import <Foundation/Foundation.h>
@interface SwimAdminAppDelegate : NSObject
{
int count;
int rest;
NSThread *thread1;
NSThread *thread2;
NSThread *thread3;
NSCondition *condation;
}
@property int count;
@property int rest;
-(void)fun1;
-(void)swim;
@end
//.m
#import "SwimAdminAppDelegate.h"
@implementation SwimAdminAppDelegate
@synthesize count;
@synthesize rest;
-(void)fun1
{
count=0;
rest=150;
condation=[[NSCondition alloc]init];
thread1=[[NSThread alloc]initWithTarget:self selector:@selector(swim) object:nil];
[thread1 setName:@"thread1"];
[thread1 start];
thread2=[[NSThread alloc]initWithTarget:self selector:@selector(swim) object:nil];
[thread2 setName:@"thread2"];
[thread2 start];
thread3=[[NSThread alloc]initWithTarget:self selector:@selector(swim) object:nil];
[thread3 setName:@"thread3"];
[thread3 start];
}
-(void)swim
{
while (TRUE) {
[condation lock];
if(rest>0)
{
NSLog(@"现在还有余票：%d张，售出：%d张 线程：%@ ",rest,count,[[NSThread currentThread]name]);
rest--;
count=150-rest;
}
else
{
break;
}
[condation unlock];
}
}
@end
//main()
#import <Foundation/Foundation.h>
#import "SwimAdminAppDelegate.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc]init];
SwimAdminAppDelegate *swimer=[[SwimAdminAppDelegate alloc]init];
[swimer fun1];
[NSThread sleepForTimeInterval:10];
}
return 0;
}
5.写出一个异常程序，并捕获它。
//Cup.h
#import <Foundation/Foundation.h>
#import "CupOverFlowException.h"
#import "CupWarningException.h"
@interface Cup : NSObject
{
int level; //成员变量，水的深度值
}
//获取水的深度值
-(int)level;
//设置水的深度值
-(void)setLevel:(int)i;
//水的深度值加10
-(void)fill;
//水的深度值减10
-(void)empty;
//输出水的深度值
-(void)print;
//计算一个百分比
-(double)set:(double)a over :(double)b;
@end
//Cup.m
#import "Cup.h"
@implementation Cup
-(id)init
{
if (self=[super init]) {
[self setLevel:0];
}
return self;
}
-(int)level
{
return level;
}
-(void)setLevel:(int)i
{
level=i;
if (level>100) {
NSException *e=[CupOverFlowException exceptionWithName:@"CupOverFlowException" reason:@"the level is above 100" userInfo:nil];
@throw e;
}
else if (level>=50)
{
NSException *e=[CupWarningException exceptionWithName:@"CupWarningException" reason:@"the level is above or at 50" userInfo:nil];
@throw e ;//抛出异常警告
}
else if(level<0)
{
NSException *e=[NSException exceptionWithName:@"CupUnderflowException" reason:@"the level is below 0" userInfo:nil];
@throw e;
}
}
-(void)fill
{
[self setLevel:level+10];
}
-(void)empty
{
[self setLevel:level-10];
}
-(void)print
{
NSLog(@"the level is %d",level);
}
-(double)set:(double)a over:(double)b
{
return a/b;
}
@end
//CupWarningException.h
#import <Foundation/Foundation.h>
@interface CupWarningException : NSException
@end
//CupWarningException.m
#import "CupWarningException.h"
@implementation CupWarningException
@end
// CupOverFlowException.h
#import <Foundation/Foundation.h>
@interface CupOverFlowException : NSException
@end
// CupOverFlowException.m
#import "CupOverFlowException.h"
@implementation CupOverFlowException
@end
//main
#import <Foundation/Foundation.h>
#import <Foundation/NSString.h>
#import <Foundation/NSException.h>
#import <Foundation/NSAutoreleasePool.h>
#import "Cup.h"
#import "CupWarningException.h"
#import "CupOverFlowException.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
NSAutoreleasePool *pool=[[NSAutoreleasePool alloc]init];
Cup *cup=[[Cup alloc]init];
int i=0;
for (i=0; i<4; i++) {
[cup fill];
[cup print];
}
for (i=0; i<7; i++) {
@try {
[cup fill];
}
@catch (CupWarningException *e) {
NSLog(@"%@ %@",[e name],[e reason]);
}
@catch (CupOverFlowException *e) {
NSLog(@"%@ %@",[e name],[e reason]);
}
@finally {
[cup print];
}
}
@try {
[cup setLevel:-1];
}
@catch (NSException *e) {
NSLog(@"%@ %@",[e name],[e reason]);
}
}
return 0;
}