oc单例怎么写_育才学习网

ios单例怎么写

1.开发中如何使用单例 ios

为你解答。

第一、基本概念单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。

通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问。第二、在IOS中使用单例模式的情况1.如果说创建一个对象会耗费很多系统资源，那么此时采用单例模式，因为只需要一个实例，会节省alloc的时间2.在IOS开发中，如果很多模块都要使用同一个变量，此时如果把该变量放入单例类，则所有访问该变量的调用变得很容易，否则，只能通过一个模块传递给另外一个模块，这样增加了风险和复杂度第三、创建单例模式的基本步骤1.声明一个单例对象的静态实例，并初始化为nil2.声明一个类的工厂方法，生成一个该类的实例，并且只会生成一个3.覆盖allcoWithZone方法，确保用户在alloc 时，不会产生一个多余的对象4.实现NSCopying协议，覆盖release,autorelease,retain,retainCount方法，以确保只有一个实例化对象5.在多线程的环境中，注意使用@synchronized关键字 [cpp] view plaincopyprint?// // UserContext.h // SingleDemo // // Created by andyyang on 9/30/13. // Copyright (c) 2013 andyyang. All rights reserved. // #import @interface UserContext : NSObject @property (nonatomic,retain) NSString *username; @property(nonatomic,retain)NSString *email; +(id)sharedUserDefault; @end [cpp] view plaincopyprint?// // UserContext.m // SingleDemo // // Created by andyyang on 9/30/13. // Copyright (c) 2013 andyyang. All rights reserved. // #import "UserContext.h" static UserContext *singleInstance=nil; @implementation UserContext +(id)sharedUserDefault { if(singleInstance==nil) { @synchronized(self) { if(singleInstance==nil) { singleInstance=[[[self class] alloc] init]; } } } return singleInstance; } + (id)allocWithZone:(NSZone *)zone; { NSLog(@"HELLO"); if(singleInstance==nil) { singleInstance=[super allocWithZone:zone]; } return singleInstance; } -(id)copyWithZone:(NSZone *)zone { NSLog(@"hello"); return singleInstance; } -(id)retain { return singleInstance; } - (oneway void)release { } - (id)autorelease { return singleInstance; } - (NSUInteger)retainCount { return UINT_MAX; }@end [cpp] view plaincopyprint?#import #import "UserContext.h" int main(int argc, const char * argv[]) { @autoreleasepool { UserContext *userContext1=[UserContext sharedUserDefault]; UserContext *userContext2=[UserContext sharedUserDefault]; UserContext *userContext3=[[UserContext alloc] init]; UserContext *userContext4=[userContext1 copy]; // insert code here。

NSLog(@"Hello, World!"); } return 0； } 在开发中我们可以利用ios提供的方法来实现单例模式：SYNTHESIZE_SINGLETON_FOR_CLASS(MyClassName)；将该语句置于@implementation MyClassName声明后，这样你的类自动会变成单例。内容来自于richard_如风的博客。

2.ios 怎么将一个viewcontroller做成单例不被释放

+ (id)sharedViewController {

static MyManager *VC = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

VC = [[self alloc] init];

});

return VC;

}

不建议将控制器设置成单例，一般单例多继承于NSobject ，控制器写成单例是一件很危险的事情。你把控制器写成单例无非就是想获取相同的一个控制器对象，获取同一个控制器总有别的办法，不需要单例。

3.ios怎么实现singleton

Singleton模式经常来做应用程序级别的共享资源控制，应该说这个模式的使用频率非常高，现在来看看在Objective-C里面的实现方法.要实现一个Singleton Class，至少需要做以下四个步骤：1. 为Singleton Object实现一个静态实例，初始化，然后设置成nil.2. 实现一个实例构造方法（通常命名为 sharedInstance 或者 sharedManager）检查上面声名的静态实例是否为nil，如果是则新建并返回一个本类实例.3. 重写 allocWithZone：方法来保证当其他人直接使用 alloc 和 init 试图获得一个新实例的时候不会产生一个新的实例.4. 适当的实现 copyWithZone:, release, retain, retainCount 和 autorelease.@interface MySingleton : NSObject { // 。

}+ (MySingleton *)sharedInstance;// Interface- (NSString *)helloWorld;@end#import "MySingleton.h"static MySingleton *sharedInstance = nil;@implementation MySingleton#pragma mark Singleton methods+ (MySingleton *)sharedInstance { @synchronized(self) { if (sharedInstance == nil) { sharedInstance = [[MySingleton alloc] init]; } } return sharedInstance;}+ (id)allocWithZone:(NSZone *)zone { @synchronized(self) { if (sharedInstance == nil) { sharedInstance = [super allocWithZone:zone]; return sharedInstance; // assignment and return on first allocation } } return nil; // on subsequent allocation attempts return nil}- (id)copyWithZone:(NSZone *)zone { return self;}- (id)retain { return self;}- (unsigned)retainCount { return UINT_MAX; // denotes an object that cannot be released}- (void)release { //do nothing}- (id)autorelease { return self;}#pragma mark -#pragma mark NSObject methods- (id)init { if (self = [super init]) { // 。 } return self;}- (void)dealloc { // 。

[super dealloc];}#pragma mark -#pragma mark Implementation- (NSString *)helloWorld { return @"Hello World!";}@end#import "MySingleton.h"// 。NSLog(@"Result for singleton method helloWorld: %@", [[MySingleton sharedInstance] helloWorld]);。

4.ios 单例设计模式解决什么用

单例模式：在单例模式中，对活动的单例只有一个实例。

对单例类的所有实例化得到的都是相同的一个实例。这个模式也提供一个全局的接口来访问这个类的实例。

public class Singleton { //Fields private static Singleton instance; //Standard default Constructor protected Singleton(){}; //Static method for creating the single instance of the Constructor public static Singleton Instance(){ //initialize if not already done if(instance == null) instance = new Singleton(); //return the initialized instance of the Singleton Class return instance; } }public class Client { public static void main(String []args){ Singleton s1 = Singleton.Instance(); Singleton s2 = Singleton.Instance(); if(s1 == s2) System.out.println("The same instance")； } }单例模式的优点： 1。实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。

2。伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

5.ios 程序启动时为什么重新创建单例类

[cpp] view plaincopy static AccountManager *DefaultManager = nil; + (AccountManager *)defaultManager { if (!DefaultManager) DefaultManager = [[self allocWithZone:NULL] init]; return DefaultManager； } 当然，在iOS4之后有了另外一种写法：[cpp] view plaincopy+ (AccountManager *)sharedManager { static AccountManager *sharedAccountManagerInstance = nil; static dispatch_once_t predicate; dispatch_once(&predicate, ^{ sharedAccountManagerInstance = [[self alloc] init]; }); return sharedAccountManagerInstance； } 该写法来自 objcolumnist，文中提到，该写法具有以下几个特性：1. 线程安全。

2. 满足静态分析器的要求。3. 兼容了ARC 然后我还有点好奇的是dispatch_once，这个函数，没见过啊。

于是就到官方的文档里找找看，是怎么说的。下面是官方文档介绍：dispatch_once Executes a block object once and only once for the lifetime of an application. void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block); Parameters predicate A pointer to a dispatch_once_t structure that is used to test whether the block has completed or not.block The block object to execute once.Discussion This function is useful for initialization of global data (singletons) in an application. Always call this function before using or testing any variables that are initialized by the block.If called simultaneously from multiple threads, this function waits synchronously until the block has completed.The predicate must point to a variable stored in global or static scope. The result of using a predicate with automatic or dynamic storage is undefined.Availability Available in iOS 4.0 and later.Declared In dispatch/once.h 我们看到，该方法的作用就是执行且在整个程序的声明周期中，仅执行一次某一个block对象。

简直就是为单例而生的嘛。而且，有些我们需要在程序开头初始化的动作，如果为了保证其，仅执行一次，也可以放到这个dispatch_once来执行。

然后我们看到它需要一个断言来确定这个代码块是否执行，这个断言的指针要保存起来，相对于第一种方法而言，还需要多保存一个指针。方法简介中就说的很清楚了：对于在应用中创建一个初始化一个全局的数据对象（单例模式），这个函数很有用。

如果同时在多线程中调用它，这个函数将等待同步等待，直至该block调用结束。这个断言的指针必须要全局化的保存，或者放在静态区内。

使用存放在自动分配区域或者动态区域的断言，dispatch_once执行的结果是不可预知的。总结：1.这个方法可以在创建单例或者某些初始化动作时使用，以保证其唯一性。

2.该方法是线程安全的，所以请放心大胆的在子线程中使用。（前提是你的dispatch_once_t *predicate对象必须是全局或者静态对象。

这一点很重要，如果不能保证这一点，也就不能保证该方法只会被执行一次。）。

6.ios 怎么宏定义封装一个单例

#define SYNTHESIZE_SINGLETON_FOR_CLASS(classname) \\static classname *shared##classname = nil; \\+ (classname *)shared##classname \{ \@synchronized(self) \{ \if (shared##classname == nil) \{ \shared##classname = [self alloc] init]; \} \} \\return shared##classname; \} \\。

7.iOS中创建单例为什么使用static关键字,不用有什么影响

首先你要明白static 是在什么时候初始化的，其设计意图是是什么，单例就是我们运行的当前虚拟机中有且只有一个需要的对象，不存在重复。

static 是给类静态成员变量使用的，属于类的属性，一般是一些常量之类的东西，从加载上来说对于类和对象之间，在类加载到内存时候静态成员变量就存在了，而对象还不存在，另外静态方法只能调用静态方法和静态变量这个你也应该知道，如果全部搞成静态方法那么意味着其他成员变量都要是静态的，很不方便，如果一天不要单例了也不容易扩展，很麻烦。

ios单例怎么写

单例怎么写

1. 这个单例的写法跟一般的写法有什么区别

感觉这么写可以防止并发操作导致多次实例化例如以下常规写法：public class Singleton { private Singleton() {} private static Singleton instance = null; public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance； }}当并发调用Singleton.getInstance（)时，可能会让new Singleton（)执行多次；当然改成如下形式也可以避免这种问题：public class Singleton { private Singleton() {} private static Singleton instance = new Singleton(); public static Singleton getInstance() { return instance; }}。

2. 如何写一个简单的单例模式

一、基本的实现思路：

单例的实现主要是通过以下两个步骤：

1、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；

2、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

二、示范如下：

1、枚举实现单例：

2、懒汉式线程不安全：

3、懒汉式线程安全：

4、饿汉式：

5、双重校验锁：

6、静态内部类：

扩展资料：

一、单列模式简介：

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。

二、懒汉与饿汉：

1、懒汉方式：指全局的单例实例在第一次被使用时构建。

2、饿汉方式：指全局的单例实例在类装载时构建。

三、单例模式的三要点：

1、某个类只能有一个实例。

2、它必须自行创建这个实例。

3、它必须自行向整个系统提供这个实例。

四、优缺点：

1、优点：

①实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

②灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。

2、缺点：

①开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

②可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

③对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

参考资料：百度百科单列模式

3. 单例模式怎么写,求一份饿汉式单例一份懒汉式单例

//懒汉式

public class A{

public static A a = null;

public A(){

}

public A getInstance(){

if(a==null){

return new A();

}

return a;

}

//饿汉式

public class A{

public static synchonized A a = new A（)；//线程安全

public A(){

}

public A getInstance(){

return a;

}

所谓饿就是急，无论需不需要先将单例对象给创建了，而懒汉式就是慢，需要的时候再创建，此外还有利用java缓存式的，利用内部类实现的单例模式，具体可以参考《清华大学出版社》出版的《研磨设计模式》

4. 如何写一个简单的单例模式

单例模式的要点有三个；一是某各类只能有一个实例；二是它必须自行创建这个事例；三是它必须自行向整个系统提供这个实例。

单例模式有以下的特点：

1 单例类只可有一个实例。

2 单例类必须自己创建自己这惟一的实例。

3 单例类必须给所有其他对象提供这一实例。

public class EagerSingleton

{

private static final EagerSingleton m_instance =

new EagerSingleton();

/**

* 私有的默认构造子

private EagerSingleton() { }

/**

* 静态工厂方法

public static EagerSingleton getInstance()

{

return m_instance;

}

在这个类被加载时，静态变量m_instance 会被初始化，此时类的私有构造子会被调用。这时候，单例类的惟一实例就被创建出来了。

楼主可以具体参阅阎宏博士的《Java与模式》一书的第十五章

5. 如何正确地写出单例模式

当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样教我们的。

1234567891011public class Singleton {private static Singleton instance;private Singleton (){}public static Singleton getInstance () {if (instance == null ) {instance = new Singleton();}return instance；}}这段代码简单明了，而且使用了懒加载模式，但是却存在致命的问题。当有多个线程并行调用 getInstance（) 的时候，就会创建多个实例。

也就是说在多线程下不能正常工作。懒汉式，线程安全为了解决上面的问题，最简单的方法是将整个 getInstance（) 方法设为同步（synchronized）。

123456public static synchronized Singleton getInstance () {if (instance == null ) {instance = new Singleton();}return instance；}虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance（) 方法。

但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。

双重检验锁双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null ，一次是在同步块外，一次是在同步块内。

为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。12345678910public static Singleton getSingleton () {if (instance == null ) { //Single Checkedsynchronized (Singleton.class) {if (instance == null ) { //Double Checkedinstance = new Singleton();}}}return instance ；}这段代码看起来很完美，很可惜，它是有问题。

主要在于 instance = new Singleton（) 这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。给 instance 分配内存调用 Singleton 的构造函数来初始化成员变量将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）但是在 JVM 的即时编译器中存在指令重排序的优化。

也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

我们只需要将 instance 变量声明成 volatile 就可以了。12345678910111213141516public class Singleton {private volatile static Singleton instance； //声明成 volatileprivate Singleton (){}public static Singleton getSingleton () {if (instance == null ) {synchronized (Singleton.class) {if (instance == null ) {instance = new Singleton();}}}return instance；}}有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。

但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。

也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。

从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。

其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。饿汉式 static final field这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。

12345678910public class Singleton {//类加载时就初始化private static final Singleton instance = new Singleton();private Singleton (){}public static Singleton getInstance (){return instance；}}这种写法如果完美的话，就没必要在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance（)方法。

饿汉式的创建方式在一些场景中将无法使用：譬如 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance（) 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。静态内部类 static nested class我比较倾向于使用静态内部类的方法，这种方法也是《Effective Java》上所推荐的。

123456789public class Singleton {private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}private Singleton (){}public static final Singleton getInstance () {return 。

6. java中怎么写一个单例的例子,看了许多,就是不会写.

单例就是把构造方法私有化，在类里实例化对象，并且给一个共有的能返回这个对象的方法

public class Single{

private Single s = null;

private Single(){

}

public static synchronized Single getS(){

if (s == null) {

s = new Singleton();

}

return s;

}

7. 如何正确地写出单例模式

当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样教我们的。

也就是说在多线程下不能正常工作。懒汉式，线程安全为了解决上面的问题，最简单的方法是将整个 getInstance（) 方法设为同步（synchronized）。

但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。

但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。

123456789public class Singleton {private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}private Singleton (){}public 。

8. 如何写一个单例模式

class Single(object): _instance = None _is_init = False def __new__(cls, *args, **kw): if cls._instance is None: cls._instance = object.__new__(cls, *args, **kw) return cls._instance def __init__(self): if not Single._is_init： # 给对象进行来初始源化，添加相关2113属性 # 。

# 表示对象已经初始化完成了。 Single._is_init = True你学会了吗？学习更多编5261程的知识，不知道去哪里找资料4102，黑马程序员就有很多1653哦。