单例模式三个特点：某个类只能有一个实例；必须自行创建这个实例；必须自行向整个系统提供这个实例。
饿：在私有静态成员变量时直接创建（费内存）
懒：延迟加载，到了要使用的时候再创建（线程安全问题繁琐、费性能）
双重检查锁定关键代码：
private volatile staitc LazySingleton instance = null;
private LazySingleton(){}
private static LazySingleton getInstance(){
if(instance == null){ //第一重判断
synchronized(LazySingleton.class){ //锁定代码块
if(instance == null){ //第二重判断
instance = new LazySingleton();
}
}
}
}双重检查锁定能保证线程安全问题，类静态成员变量instance需要用volatile修饰，可以确保多个线程能够正确处理，volatile会屏蔽java虚拟机做的代码优化，可能导致系统运行效率降低。
静态内部类实现：
class Singleton{
private Singleton(){}
private static class HolderClass{
private final static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return HolderClass.instance;
}
}由于静态单例没有直接实例化，相当于是延迟加载了...，第一次调用getInstance方法时将加载内部类HolderClass，此时会初始化instance，由于java虚拟机会保证其线程安全，确保该成员变量只能初始化一次，没加锁，所以性能也没影响。
effective java中，单元素枚举是单例最佳实现。
public enum Singleton{
uniqueInstance;
public void singletonOperation(){
}
}
1，负载均衡器的设计
package com.hehe.danlifuzaijunhe;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class LoadBalancer {
private static LoadBalancer instance = null;
//服务器集合
private List serverList = null;
//私有构造函数
private LoadBalancer(){
serverList = new ArrayList();
}
public static LoadBalancer getLoadBalancer(){
if (instance == null) {
instance = new LoadBalancer();
}
return instance;
}
public void addServer(String server){
serverList.add(server);
}
public void removeServer(String server){
serverList.remove(server);
}
//Random随机获取服务器
public String getServer(){
Random random = new Random();
int i = random.nextInt(serverList.size());
return (String)serverList.get(i);
}
}
package com.hehe.danlifuzaijunhe;
public class Client {
public static void main(String[] args) {
LoadBalancer balancer1, balancer2, balancer3;
balancer1 = LoadBalancer.getLoadBalancer();
balancer2 = LoadBalancer.getLoadBalancer();
balancer3 = LoadBalancer.getLoadBalancer();
balancer1.addServer("server1");
balancer1.addServer("server2");
balancer1.addServer("server3");
balancer1.addServer("server4");
balancer1.addServer("server5");
//模拟客户端请求分发给不同的服务器
for (int i = 0; i < 5; i++) {
String server2 = balancer2.getServer();
System.out.println(server2);
}
for (int i = 0; i < 5; i++) {
String server3 = balancer3.getServer();
System.out.println(server3);
}
}
}
private List serverList = null;
这个实例属性，因为是单例模式，所以这个实例属性在balancer1, balancer2, balancer3他们这三个实例看来，是一致的。如果不是用单例模式，那么实例属性是各个实例的属性，当然就不一致了，那具体到这个负载均衡的设计，就会带来服务器状态的不一致以及请求分配冲突问题。
联想一下，这种类似的思想，比如windows中的任务管理器，显示着电脑的应用程序、进程、服务、用户等信息，不管你打开多少次任务管理器，最多也只显示一个任务管理器窗口。假如能显示多个任务管理器窗口，那这些窗口里面的信息必须是一致的才行，这都是重复的，那就是浪费系统资源了。若是弹出窗口信息不一致，那就更离谱了，用户该相信哪一个呢。
再比如windows中的回收站。
2，单例模式读取配置文件
//db.properties文件 保持数据连接信息
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mydb
user=root
password=root
//单例模式读取数据配置文件 Env.java
import java.io.InputStream;
import java.util.Properties;
public class Env extends Properties {
private static Env env;
private Env() {
try {
InputStream is = this.getClass().getResourceAsStream(
"/db.properties");
this.load(is);
} catch (IOException e) {
e.printStackTrace();
}
}
public static Env createInstance() {
if (env == null) {
newInstance();
}
return env;
}
synchronized private static void newInstance() {
env = new Env();
}
}
//工具类DBConnection.java 注册驱动---->创建连接----->关闭连接
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import com.tarena.dbdx.day09.util.file.Env;
public class DBConnection {
// 注册驱动
static {
try {
//String driver = "com.mysql.jdbc.Driver";
Class.forName(Env.createInstance().getProperty("driver"));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
// 创建连接
public static Connection getConnection() throws SQLException {
/*String url = "jdbc:mysql://127.0.0.1:3306/mydb";
String user = "root";
String password = "";*/
return DriverManager.getConnection(Env.createInstance().getProperty("url"),
Env.createInstance().getProperty("user"),
Env.createInstance().getProperty("password"));
}
/**
* 关闭Statement有结果集
*/
public static void close(ResultSet rs, Statement stat, Connection conn) {
try {
if (rs != null) {
rs.close();
}
if (stat != null) {
stat.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 关闭PreparedStatement有结果集
*/
public static void close(ResultSet rs, PreparedStatement ps, Connection conn) {
try {
if (rs != null) {
rs.close();
}
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 关闭无结果集
*/
public static void close(Statement stat, Connection conn) {
try {
if (stat != null) {
stat.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(PreparedStatement ps, Connection conn) {
try {
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}这是最常见的单例模式应用了。如果不用单例模式，运行期间系统中可能会存在多个Env对象，也就是说系统中存在多份配置文件的内容，严重浪费系统资源啊。
3，java.lang.Runtime类的getRuntime()，感受一下，就是那么回事。
默认情况下，Spring会通过单例模式创建bean实例
<bean id="date" class="java.util.Date" scope="singleton"/>4，单例à多例（数据库连接池）
思路大概是酱紫的。
每次建立一个数据库连接需要花费一到三秒。而且必须要管理好每一个连接，确保正确关闭，避免内存泄露重启数据库。于是，可以考虑一个全局的Connection，创建后不关闭，这还是不科学，一个连接使用次数过多会不稳定。所以，可以将指定个数的数据库连接池对象存储在连接池中，客户端随机抽取一个连接对象来连接数据库。高端一点的话，可以搞个空闲池、使用池，类似于负载均衡。
很多服务器就自带连接池机制，配置一些就行。具体到连接池的设计，呵呵呵呵。。。并发问题、多数据库多用户、事务处理等。
这是单例模式数据库连接池
抛砖引玉，砖头暂时只有这些了。可以一起探讨一下平时能够用到单例模式的地方。以及这种思想的应用。
1722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
