Android开发中常见的设计模式

最新推荐文章于 2024-05-08 06:22:01 发布

恬静释然

最新推荐文章于 2024-05-08 06:22:01 发布

阅读量323

点赞数

分类专栏： Android设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/qq_41648631/article/details/102873709

版权

Android中常见的几种设计模式如下：

单例模式
Build模式
观测者模式
原型模式
策略模式
适配器模式
工厂方法模式

接下来对以上设计模式分别介绍。

一、单例模式

1、单例模式的概念：

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

这样做有以下几个优点：

对于那些比较耗内存的类，只实例化一次可以大大提高性能，尤其是在移动开发中。
保持程序运行的时候该中始终只有一个实例存在内存中

2、单例的实现方式：

懒汉式单例和饿汉式单例。

饿汉式:

 public class Singleton{
   
        private static Singleton singleton = new Singleton ();
        private Singleton (){
   }
        public static Singleton getInstance(){
   return singletion;}
   }

懒汉式：

   public class Singleton{
   
        private static Singleton singleton = null;
        public static synchronized synchronized getInstance(){
   
             if(singleton==null){
   
                 singleton = new Singleton();
             }
            return singleton;
        }
   }

3、实现方式的优缺点对比

3.1 时间和空间

比较上面两种写法：

懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

3.2 线程安全

（1）从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。如下示例：

public static  Singleton getInstance(){
     
    if(instance == null){
     
        instance = new Singleton();  
    }  
    return instance;  
}

程序继续运行，两个线程都向前走了一步，如下：

public static  Singleton getInstance(){
     
    if(instance == null){
     
         instance = new Singleton();  
    }  
    return instance;  
}

明显地看出，当A、B线程并发的情况下，会创建出两个实例来，也就是单例的控制在并发情况下失效了。

（2）饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

（3）如何实现懒汉式的线程安全呢？

当然懒汉式也是可以实现线程安全的，只要加上synchronized即可，如下：

public static synchronized Singleton getInstance(){
   }

但是这样一来，会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式来实现呢？

（4）双重检查加锁

可以使用"双重检查加锁"的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。那么什么是"双重检查加锁"机制呢？

所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。

看看代码可能会更加清楚些。示例代码如下：

public class Singleton {
     
      
    private volatile static Singleton instance = null;  
    private Singleton(){
     
    }  
    public static  Singleton getInstance(){
     
        //先检查实例是否存在，如果不存在才进入下面的同步块  
        if(instance == null){
     
            //同步块，线程安全地创建实例  
            synchronized(Singleton.class){
     
                //再次检查实例是否存在，如果不存在才真正地创建实例  
                if(instance == null){
     
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

这种实现方式可以实现既线程安全地创建实例，而又不会对性能造成太大的影响。它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。

要保证单例，需要做一下几步：

必须防止外部可以调用构造函数进行实例化，因此构造函数必须私有化。

必须定义一个静态函数获得该单例

单例使用volatile修饰

使用synchronized 进行同步处理，并且双重判断是否为null，我们看到synchronized (Singleton.class)里面又进行了是否为null的判断，这是因为一个线程进入了该代码，如果另一个线程在等待，这时候前一个线程创建了一个实例出来完毕后，另一个线程获得锁进入该同步代码，实例已经存在，没必要再次创建，因此这个判断是否是null还是必须的。

此外，单例对象经常使用static，如果持有Context，很容易引发内存泄漏。

4、单例的并发

至于单例的并发测试，可以使用CountDownLatch，使用await()等待锁释放，使用countDown()释放锁从而达到并发的效果。可以见下面的代码：

	public static void main(String[] args) {
   
		final CountDownLatch latch = new CountDownLatch(1);
		int threadCount = 1000;
		for (int i = 0; i < threadCount; i++) {
   
			new Thread() {
   
				@Override
				public void run() {
   
					try {
   
						latch.await();
					} catch (InterruptedException e) {
   
						e.printStackTrace();
					}
					System.out.println(Singleton.getInstance().hashCode());
				}
			}.start();
		}
		latch.countDown();
}

看看打印出来的hashCode会不会出现不一样即可，理论上是全部都一样的。

5、单例模式在Android中的使用

比如Android-Universal-Image-Loader中的单例：

	private volatile static ImageLoader instance;
/** Returns singleton class instance */
public static ImageLoader getInstance() {
   
	if (instance == null) {
   
		synchronized (ImageLoader.class) {
   
			if (instance == null) {
   
				instance = new ImageLoader();
			}
		}
	}
	return instance;
}

比如EventBus中的单例：

	private static volatile EventBus defaultInstance;
public static EventBus getDefault() {
   
	if (defaultInstance == null) {
   
		synchronized (EventBus.class) {
   
			if (defaultInstance == null) {
   
				defaultInstance = new EventBus();
			}
		}
	}
	return defaultInstance;
}

上面的单例都是比较规规矩矩的，当然实际上有很多单例都是变了一个样子，单本质还是单例。
如InputMethodManager 中的单例：

static InputMethodManager sInstance;
public static InputMethodManager getInstance() {
   
	synchronized (InputMethodManager.class) {
   
		if (sInstance == null) {
   
			IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
			IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
			sInstance = new InputMethodManager(service, Looper.getMainLooper());
		}
		return sInstance;
	}
}

AccessibilityManager 中的单例，看代码这么长，其实就是进行了一些判断，还是一个单例：

private static AccessibilityManager sInstance;
public static AccessibilityManager getInstance(Context context) {
   
	synchronized (sInstanceSync) {
   
		if (sInstance == null) {
   
			final int userId;
			if (Binder.getCallingUid() == Process.SYSTEM_UID
					|| context.checkCallingOrSelfPermission(
							Manifest.permission.INTERACT_ACROSS_USERS)
									== PackageManager.PERMISSION_GRANTED
					|| context.checkCallingOrSelfPermission(
							Manifest.permission.INTERACT_ACROSS_USERS_FULL)
									== PackageManager.PERMISSION_GRANTED) {
   
				userId = UserHandle.USER_CURRENT;
			} else {
   
				userId = UserHandle.myUserId();
			}
			IBinder iBinder = ServiceManager.getService(Context.ACCESSIBILITY_SERVICE);
			IAccessibilityManager service = IAccessibilityManager.Stub.asInterface(iBinder);
			sInstance = new AccessibilityManager(context, service, userId);
		}
	}
	return sInstance;
}

当然单例还有很多种写法，比如恶汉式，有兴趣的自己去了解就好了。
最后，我们应用一下单例模式。典型的一个应用就是管理我们的Activity，下面这个可以作为一个工具类，代码也很简单，以下是代码。

public class ActivityManager {
   

	private static volatile ActivityManager instance;
	private Stack<Activity> mActivityStack = new Stack<Activity>();
	
	private ActivityManager(){
   
		
	}
	
	public static ActivityManager getInstance(){
   
		if (instance == null) {
   
		synchronized (ActivityManager.class) {
   
			if (instance == null) {
   
				instance = new ActivityManager();
			}
		}
		return instance;
	}
	
	public void addActicity(Activity act){
   
		mActivityStack.push(act);
	}
	
	public void removeActivity(Activity act){
   
		mActivityStack.remove(act);
	}
	
	public void killMyProcess(){
   
		int nCount = mActivityStack.size();
		for (int i = nCount - 1; i >= 0; i--) {
   
        	Activity activity = mActivityStack.get(i);
        	activity.finish();
        }
		
		mActivityStack.clear();
		android.os.Process.killProcess(android.os.Process.myPid());
	}
}

二、Build模式

1、定义：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

但是看完这个定义，你依然不知道什么是Builder设计模式。在此个人的态度是学习设计模式这种东西，不要过度在意其定义，定义往往是比较抽象的，学习它最好的例子就是通过样例代码。

我们通过一个例子来引出Builder模式。假设有一个Person类，我们通过该Person类来构建一大批人，这个Person类里有很多属性，最常见的比如name，age，weight，height等等，并且我们允许这些值不被设置，也就是允许为null，该类的定义如下。

	public class Person {
   
    private String name;
    private int age;
    private double height;
    private double weight;

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }

    public double getHeight() {
   
        return height;
    }

    public void setHeight(double height) {
   
        this.height = height;
    }

    public double getWeight() {
   
        return weight;
    }

    public void setWeight(double weight) {
   
        this.weight = weight;
    }
}

然后我们为了方便可能会定义一个构造方法。

public Person(String name, int age, double height, double weight) {
   
	this.name = name;
	this.age = age;
	this.height = height;
	this.weight = weight;
}

或许为了方便new对象，你还会定义一个空的构造方法

public Person() {
   
}

甚至有时候你很懒，只想传部分参数，你还会定义如下类似的构造方法。

public Person(String name) {
   
	this.name = name;
}

public Person(String name, int age) {
   
	this.name = name;
	this.age = age;
}

public Person(String name, int age, double height) {
   
	this.name = name;
	this.age = age;
	this.height = height;
}

于是你就可以这样创建各个需要的对象

Person p1=new Person();
Person p2=new Person("张三");
Person p3=new Person("李四",18);
Person p4=new Person("王五",21,180);
Person p5=new Person("赵六",17,170,65.4);

可以想象一下这样创建的坏处，最直观的就是四个参数的构造函数的最后面的两个参数到底是什么意思，可读性不怎么好，如果不点击看源码，鬼知道哪个是weight哪个是height。还有一个问题就是当有很多参数时，编写这个构造函数就会显得异常麻烦，这时候如果换一个角度，试试Builder模式，你会发现代码的可读性一下子就上去了。
我们给Person增加一个静态内部类Builder类，并修改Person类的构造函数，代码如下。

public class Person {
   
    private String name;
    private int age;
    private double height;
    private double weight;

    private Person(Builder builder) {
   
        this.name=builder.name;
        this.age=builder.age;
        this.height=builder.height;
        this.weight=builder.weight;
    }

最低0.47元/天解锁文章

恬静释然

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android开发中常见的设计模式

一、单例模式1、单例模式的概念：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这样做有以下几个优点：对于那些比较耗内存的类，只实例化一次可以大大提高性能，尤其是在移动开发中。保持程序运行的时候该中始终只有一个实例存在内存中2、单例的实现方式：懒汉式单例和饿汉式单例。饿汉式: public class Singleton{ priva...
复制链接

扫一扫