单例模式的思想简介

单例的基本思维

单例是一种保证对象只有一个的设计模式。

比如数据库连接。如果用hibernate，会在应用初始化时，就创建数据库连接。在访问时通过方法，而不是通过new产生。

对比其他的几种做法：

1在需要时new连接对象，用完后关闭。这样频繁的开和关，效率低。同时代码融入很多无关的成分。

2在初始化时new，放到全局区，比如java web的application context中。这种访问太直接了。

单例的经典实现(代码)

也可以参考这篇文章

http://www.cnblogs.com/BoyXiao/archive/2010/05/07/1729376.html?login=1

单例的本质

1单例是一种保证对象只有一个的设计模式。

2单例的本质在于共享

1并没有说明什么时候该用单例模式，而2则是针对这点的。

共享有两种情况：

由于使用共享的资源（如static，文件等），不得不由共享对象来操作。

某对象比较复杂，不应该每个使用者都创建一个，所以共享。

3单例和全局变量

从使用角度来说，单例和全局变量都是为了共享。但唯有单例才能保证对象只有一个，所以单例和全局变量有所不同。

但有时单例不一定用getInstance的方法实现的。比如说Spring中也把动态生成的对象叫单例，这种单例并没有用单例模式约束的，仅仅就是用户不自己创建，而是使用Spring提供的那个对象（本质上是放在session的全局变量，但也有人叫这种对象单例）

4单例不一定是只有一个的

       比如qq软件的登录状态对象，我们希望每个用户在某一时刻只有一个登录状态对象，不可以在两台机子同时上q。那么在服务端就会为每个用户的登录状态建立一个单例。比如

单例的重要概念

1单例的生存周期。单例什么时候会销毁。有的是request级的，有的是session级的，有的是application级的。这主要看单例依赖于什么。比如登录信息放在session中，就会是session基本的。单例常常用static实现，由于static属于类成员，只有在应用停止时才会销毁，所以是application级别的。

2单例与多线程。既然单例共享资源，就一定要考虑多线程问题。对操作共享资源的函数，就要加同步了。百闻不如一见，还是贴一段代码，代码的背景是这样的，数据库中存了树形结构的数据，这个类RoleTree把树结构读出来，缓存到static中。作为一个单例给需要使用这颗树的地方调用。

package com.xcat.user;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import com.xcat.common.DB;

public class RoleTree {
    private Map<Integer,Role> treeUp;
    private Map<Integer,Set<Integer>> treeDown;
    private static RoleTree instance = null;
    private RoleDao roleDao;
    
    private RoleTree() {
        roleDao = new RoleDao();
        reinit(roleDao.list());
    }
    
    public static synchronized RoleTree getInstance() {   
        if (instance == null) {   
            instance = new RoleTree(); 
        }
        return instance;
    }  
    
    public void reinit(List<Role> ls){
        
        treeUp = new HashMap<Integer,Role>();
        treeDown = new HashMap<Integer,Set<Integer>>();
        for(Role r : ls){
            treeUp.put(r.getId(), r);
            treeDown.put(r.getId(), new HashSet<Integer>());
        }
        treeDown.put(0,new HashSet<Integer>());
        for(Role r : ls){
            treeDown.get(r.getParentId()).add(r.getId());
        }
    }
    
    public synchronized void add(Role r){
        roleDao.add(r); 
        r= roleDao.loadByName(r.getName());
        treeUp.put(r.getId(), r);
        treeDown.put(r.getId(), new HashSet<Integer>());
        treeDown.get(r.getParentId()).add(r.getId());
        
    }
    
    public void addAsRoot(Role r){
        r.setParentId(0);
        add(r);    
    }
    
    public void addByParent(Role r,int parentId){
        r.setParentId(parentId);
        add(r);
    }
    
    public List<Role> getChildren(int id){
        List<Role> ls= new ArrayList<Role>();
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(id);
        while (queue.peek()!=null){
            int cur=queue.poll();
            ls.add(treeUp.get(cur));
            Set<Integer> set=treeDown.get(cur);
            if(set!=null)
                for(int i : set) queue.offer(i);
        }
        
        for(Role r : ls) 
            if(r.getId()==0) {
                ls.remove(r);
                break;
            }
        
        return ls;
    }
    
    public List<Role> list(){
        List<Role> ls= new ArrayList<Role>();
        for(Role r : treeUp.values()){
            ls.add(r);
        }
        
        for(Role r : ls) 
            if(r.getId()==0) {
                ls.remove(r);
                break;
            }
        
        return ls;
    }
    
    public Role loadById(int id) {
        Role r;
        if(treeUp.containsKey(id)) r=treeUp.get(id);
        else r=null;
        return r;
    }
    
    public List<Object[]> getIndentName(){
        List<Object[]> ls= new ArrayList<Object[]>();
        for(int i : treeDown.get(0)) _getInent(ls,i,0);
        return ls;
    }
    
    private void _getInent(List<Object[]> ls, int cur ,int level){
        
        Object[] objs =new Object[2];
        objs[0]=treeUp.get(cur).getId();
        String name="";
        for(int i=0;i<level;i++) name+="-";
        objs[1]=name+treeUp.get(cur).getName();
        ls.add(objs);
        
        for(int i : treeDown.get(cur))
            _getInent(ls,i,level+1);
    }
    
    private void showTreeDown(){
        for(int key : treeDown.keySet()) {
            for(int i : treeDown.get(key)) System.out.print(i+",");
            System.out.println("");
        }
    }
    
    public synchronized  void update(Role r) {
        roleDao.update(r);
        
        int oldId=treeUp.get(r.getId()).getParentId();
        treeDown.get(oldId).remove(r.getId());
        treeUp.remove(r.getId());
        
        treeUp.put(r.getId(), r);
        treeDown.get(r.getParentId()).add(r.getId());
    }
    
    public synchronized void updateParent(int id , int parentId) {
        roleDao.updateParent(id, parentId);
        
        int oldId=treeUp.get(id).getParentId();
        treeDown.get(oldId).remove(id);
        
        treeUp.get(id).setParentId(parentId);
        treeDown.get(parentId).add(id);
    }
    
    public void delete(Role r) {
        deleteById(r.getId());
    }
    
    public synchronized boolean deleteById(int id) {
        if(treeDown.get(id).size()!=0) return false;
        
        roleDao.deleteById(id);
        
        int oldId=treeUp.get(id).getParentId();
        treeUp.remove(id);
        treeDown.get(oldId).remove(id);
        treeDown.remove(id);
        return true;
    }
    
    public synchronized void deleteBranch(int id) {
        List<Role> ls=getChildren(id);
        System.out.println("size:"+ls.size());
        List<Integer> lsi=new ArrayList<Integer>();
        for(Role r : ls) lsi.add(r.getId());
        roleDao.deletebyIds(lsi);
        
        reinit(roleDao.list());
    }
}

类关系（类图）

 

参考文章：http://blog.csdn.net/hguisu/article/details/7515416