Android开发技术

1:设计模式(单例模式):

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

2 、单例类必须自己创建自己的唯一实例。

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

一、懒汉式单例

[java]  view plain  copy  print ?

1. //懒汉式单例类.在第一次调用的时候实例化自己
2. public class Singleton {
3. private Singleton() {}
4. private static Singleton single=null;
5. //静态工厂方法
6. public static Singleton getInstance() {
7. if (single == null) {
8. single = new Singleton();
9. }
10. return single;
11. }
12. }

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

1、在getInstance方法上加同步

[java]  view plain  copy  print ?

1. public static synchronized Singleton getInstance() {
2. if (single == null) {
3. single = new Singleton();
4. }
5. return single;
6. }

二、饿汉式单例

[java]  view plain  copy  print ?

1. //饿汉式单例类.在类初始化时，已经自行实例化
2. public class Singleton1 {
3. private Singleton1() {}
4. private static final Singleton1 single = new Singleton1();
5. //静态工厂方法
6. public static Singleton1 getInstance() {
7. return single;
8. }
9. }

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，

所以天生是线程安全的。

1:当内部类访问外部类的时候,需要加 final.

单例步骤:(懒汉式)

1:声明一个类

2:构造函数私有化

3:声明一个静态对象(不适应呢final修饰)

4:封装一个静态方法(方法里面实例化对象)(但是线程不安全的)

三种方式保证线程安全(1,加同步锁,2:双锁机制3,静态内部类)

(1): 在getInstance方法上加同步

1. public static synchronized Singleton getInstance() {
2. if (single == null) {
3. single = new Singleton();
4. }
5. return single;
6. }

(2): 双重检查锁定

1. public static Singleton getInstance() {
2. if (singleton == null) {
3. synchronized (Singleton.class) {
4. if (singleton == null) {
5. singleton = new Singleton();
6. }
7. }
8. }
9. return singleton;
10. }

(3): 静态内部类

1. public class Singleton {
2. private static class LazyHolder {
3. private static final Singleton INSTANCE = new Singleton();
4. }
5. private Singleton (){}
6. public static final Singleton getInstance() {
7. return LazyHolder.INSTANCE;
8. }
9. }

2:饿汉式

1:创建一个类

2:构造函数私有化

3:创建一个静态对象,并且实例化,并使用final修饰(使用final修饰的原因是保证对象不可改变)

4:创建一个静态方法返回该实例对象

静态代码块啥时候执行:(静态代码块优先于主函数执行)