单例模式三个特点：某个类只能有一个实例；必须自行创建这个实例；必须自行向整个系统提供这个实例。
饿：在私有静态成员变量时直接创建（费内存）
懒：延迟加载，到了要使用的时候再创建（线程安全问题繁琐、费性能）
双重检查锁定关键代码：
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"/>
相关推荐
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
"设计模式单例模式和工厂模式综合应用"的主题聚焦于两种常用的设计模式：单例模式和工厂模式，并探讨它们如何协同工作来实现高效、灵活的代码结构。这个主题尤其适用于Java编程语言，因为Java的面向对象特性使得设计...
单例模式是软件设计模式中的一种经典模式，它保证了类只有一个实例存在，并提供一个全局访问点。在Java等面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。结合工厂模式，...
单例模式是软件设计模式中的一种经典模式，用于确保一个类只有一个实例，并提供一个全局访问点。在Java中，有多种实现单例模式的方法，每种都有其特点和适用场景。接下来，我们将深入探讨这些实现方式。 首先，我们...
在C++编程中，单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点。线程安全的单例模式在多线程环境下尤其重要，因为不正确的实现可能导致多个线程创建多个实例，这违反了单例模式...
**设计模式——单例模式** 在软件工程中，设计模式是一种在特定场景下解决常见问题的标准方案，可以被复用并提升代码质量。单例模式是设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。这种模式...
单例模式是软件设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。在C#中，单例模式常用于管理共享资源或控制类的实例化过程，以提高性能、节约系统资源，特别是在整个应用程序生命周期内只需要一...
单例模式是软件设计模式中的一种经典模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下非常有用，比如控制共享资源、管理配置对象等。下面将详细介绍七种常见的单例模式实现...
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
在C++编程中，单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在这个特定的场景中，我们讨论的是一个实现了单例模式的日志类，该类专为多线程环境设计，具备日志等级控制、...
首先向关注过我这个系列...这立刻让我想到了最常用也是最简单最容易理解的一个设计模式 单例模式 何为 单例模式 ？ 故名思议 即 让 类 永远都只能有一个实例。 由于 示例代码 比较简单 我也加了注释，这里就不在赘述
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下都非常有用，比如控制资源的唯一性、管理共享配置或者创建昂贵的对象时避免频繁创建销毁。 ...
Java中的单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供全局访问点。在Java编程中，单例模式常用于控制资源的访问，比如数据库连接池、线程池或者日志对象等。本篇文章将深入探讨如何在Java中...
单例模式是一种设计模式，它的主要目标是确保一个类只有一个实例，并提供一个全局访问点。在软件工程中，单例模式常用于控制资源的共享，比如数据库连接池、线程池或者日志系统等，这些资源通常需要全局唯一且高效地...
单例模式是软件设计模式中的一种，它的核心思想是确保一个类在整个系统中只有一个实例，并提供一个全局访问点。在Java或类似编程语言中，单例模式常常被用来管理资源，比如数据库连接、线程池或者配置信息，因为这些...
在Qt的Qml环境中，单例模式是一种设计模式，它允许在整个应用程序中创建一个全局访问点，确保某个类只有一个实例存在。这样的设计模式在需要共享数据或者服务时非常有用，避免了多处创建相同对象导致的数据不一致或...
单例模式是软件设计模式中的经典模式之一，其主要目的是控制类的实例化过程，确保在应用程序的整个生命周期中，某个类只有一个实例存在。这样的设计通常适用于那些需要频繁创建和销毁，但资源消耗较大的对象，如...
单例模式是一种常用的设计模式，它的核心思想是在整个应用程序中，一个类只能有一个实例存在。单例模式常用于控制资源的共享，例如数据库连接池、日志服务等。单例模式有多种实现方式，常见的包括懒汉式、饿汉式以及...
单例模式是软件设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。在C++中，实现单例模式有多种方法，我们将会深入探讨这一模式的原理、优缺点以及如何在实际编程中应用。 单例模式的核心在于...