单例模式（多例，线程安全）

单例模式的本质是控制实例的个数，例如限制代码中的实例个数为确定的n个，一般情况下为1个。看代码：

class ConnectionManager {
private static ConnectionManager manager = new ConnectionManager();
private ConnectionManager() {
}

public static ConnectionManager getInstance() {
return manager;
}
}

这种属于“饱汉式”的单例模式，不管你什么时候调用，当加载这个类的时候，就初始化了该类的唯一对象。这种写法是线程安全的。在下面的这种情况下，JVM隐含的为您执行的同步。

1 由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

2 访问final字段时

class ConnectionManager {
private static ConnectionManager manager = null;
private ConnectionManager() {
}

public static ConnectionManager getInstance() {
if(manager==null){
manager = new ConnectionManager();
}
return manager;
}
}

这种写法属于“饿汉式”的单例模式，只有当需要的时候才去创建。当然，上述代码不是线程安全的。（既不是静态字段，也不是static{}字段）,下面给出线程安全的代码：(用synchronized锁住ConnectionManager，表明一个时刻只能有一个线程访问ConnectionManager这个类 ,volatile修饰manager表明当manager被其他线程修改了，所有的线程都可以看到)

class ConnectionManager {
private volatile static ConnectionManager manager = null;
private ConnectionManager() {
}

public static ConnectionManager getInstance() {
if(manager==null){
synchronized(ConnectionManager.class){
if(manager==null)
manager = new ConnectionManager();
}
}
return manager;
}
}

下面将给出一个多例模式。

package com.guo.task;
/**
* 显示如何扩展单例模式，控制单例的个数为3个
* @author guo
*/
public class OneExtend{
//定义一个缺省的key值的前缀
private final static String DEFAULT_PREKEY="Cache";
//定义缓存实例的容器
private static Map<String,OneExtend> map=new HashMap<String,OneExtend>();
//用来记录当前正在使用第几个实例，到了控制的最大输入，就返回从1开始
private static int num=1;
//定义最大的实例的数目
private final static int NUM_MAX=3;

public static OneExtend getInstance(){
String key=DEFAULT_PREKEY+num;
OneExtend oneExtend=map.get(key);
if(oneExtend==null){
oneExtend =new OneExtend();
map.put(key,oneExtend);
}
//把当前的实例序号加1
num++;
if(num>NUM_MAX){
num=1;
}
return oneExtend;
}
}

当然，上述代码也不是线程安全的。具体的修改方式就留给大家来改吧。下面将给出一段强大的代码。该代码用于模拟数据库连接。比如假设有5个数据库连接，但是同时可能有8个人来获取连接。获取到连接的人，进行自己的业务操作，没获取到连接的人，则等待直到有人释放了连接，然后获取连接，处理自己的业务。

package com.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiModle {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService exec = Executors.newCachedThreadPool();

Runnable runnable = new Runnable() {

public void run() {
try {
Connection con = ConnectionManager.getInstance()
.getConnection();
System.out.println(Thread.currentThread().getId()
+ "获取到连接.." + con);
System.out.println("使用连接中..");
Thread.sleep(1000);//模拟业务操作
ConnectionManager.getInstance().releaseConnection(con);
System.out.println(Thread.currentThread().getId()
+ "使用结束,释放连接" + con);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (NotFoundException e) {
e.printStackTrace();
}

}
};
for (int i = 0; i < 8; i++) {
exec.execute(runnable);
}
exec.shutdown();
}

}

class NotFoundException extends Exception {
public NotFoundException() {
super("the connection is not founded.");
}
}

class Connection {
boolean isUsed;
private int id;

public Connection(int id) {
this.id = id;
}

public String toString() {
return id + "号连接";
}
}

class ConnectionManager {
private static ConnectionManager manager = new ConnectionManager();
private int num = 5;
private List<Connection> list;

private ConnectionManager() {
list = new ArrayList<Connection>();
for (int i = 0; i < num; i++) {
list.add( new Connection(i));
}
}

public static ConnectionManager getInstance() {
return manager;
}

public synchronized Connection getConnection() throws InterruptedException {
Connection con = null;
while (con == null) {
for (int i = 0; i < num; i++) {
if (!list.get(i).isUsed) {
con = list.get(i);
con.isUsed=true;
break;
}
}
if (con == null) {
System.out.println(Thread.currentThread().getId()
+ "号线程正在等待...");
wait();
}
}
return con;
}

public synchronized void releaseConnection(Connection con)
throws NotFoundException {
for (int i = 0; i < num; i++) {
if (list.get(i) == con) {
con.isUsed = false;
notifyAll();
return;
}
}
throw new NotFoundException();
}
}

运行结果如下所示：

10获取到连接..0号连接
使用连接中..
13获取到连接..1号连接
使用连接中..
16获取到连接..2号连接
使用连接中..
12获取到连接..4号连接
使用连接中..
11号线程正在等待...
15获取到连接..3号连接
使用连接中..
17号线程正在等待...
14号线程正在等待...
10使用结束,释放连接0号连接
12使用结束,释放连接4号连接
15使用结束,释放连接3号连接
16使用结束,释放连接2号连接
14获取到连接..0号连接
使用连接中..
13使用结束,释放连接1号连接
17获取到连接..1号连接
使用连接中..
11获取到连接..2号连接
使用连接中..
11使用结束,释放连接2号连接
14使用结束,释放连接0号连接
17使用结束,释放连接1号连接