java单例初始化（java初始化语句）

本篇文章给大家谈谈java单例初始化，以及java初始化语句对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、java之单例设计模式
• 2、java 单例模式
• 3、java问题，servlet问题，servlet在什么时候被初始化？它是线程安全吗？
• 4、求java大牛，关于单例模式的使用问题，小白真心求教
• 5、JAVA单例模式有哪些？

java之单例设计模式

设计模式 解决某一类问题最行之有效的方法 （java中有 种通用设计模式）单例设计模式 解决一个类在内存中只存在一个对象 单例设计模式有两种方式 ）饿汉式先初始化对象 当类一进内存就创建好对象 ）懒汉式对象是方法被调用时才初始化 也叫延时加载 类进内存时 对象还没有存在 只有通过方法调用时 才建立对象 单例设计模式 是想要保证对象的唯一 ）为了避免其他程序过多建立该类对象 先禁止其他程序建立该类对象 ）还为了让其他程序可以访问到该类对象 只好在本类中自定义一个对象 ）为了方便其他程序对自定义对象的访问 可以对外其他一些访问方式 利用这三步进行代码实现 ）将构造函数私有化 ）在类中创建一个本类对象 ）提供一个方法可以获取到该对象提示 在单例设计模式中 事物该怎么描述还怎么描述 当需要将该事物的对象保证在内存中唯一时 加上以上三步即可 代码说明 // ）饿汉式[java]class Single{private int num;public void setNum（int num）{this num = num;}public int getNum（）{return num;}//将构造函数私有化private Single（）{}//在类中创建一个本类对象 因为构造函数被私有化 该类不能创建对象 想在外部访问 所以将其静态private static Single s = new Single（） //提供一个方法可以获取到该对象 不能创建对象 所以将方法静态 可以通过 （类名 方法名）的形式进行访问public static Single getInstance（）{return s;}}class SingleDemo{public static void main（String[] args）{//单例的构造函数被静态后不能创建对象 保证对象的唯一 所以通过 （类名 方法名）的形式进行访问Single s = Single getInstance（） Single s = Single getInstance（） s setNum（ ） System out println（s getNum（）） //结果 因为Single单例里面对对象和方法进行了静态 数据共享 所以s 的值}}

lishixinzhi/Article/program/Java/hx/201311/26060

java 单例模式

JAVA单例模式的几种实现方法

1.饿汉式单例类

package pattern.singleton;

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 {

//私有的默认构造子

private Singleton1() {}

//已经自行实例化

private static final Singleton1 single = new Singleton1();

//静态工厂方法

public static Singleton1 getInstance() {

return single;

}

}

2.懒汉式单例类

package pattern.singleton;

//懒汉式单例类.在第一次调用的时候实例化

public class Singleton2 {

//私有的默认构造子

private Singleton2() {}

//注意，这里没有final

private static Singleton2 single;

//只实例化一次

static{

single = new Singleton2();

}

//静态工厂方法

public synchronized static Singleton2 getInstance() {

if (single == null) {

single = new Singleton2();

}

return single;

}

}

在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。有些设计师在这里建议使用所谓的"双重检查成例".必须指出的是，"双重检查成例"不可以在Java 语言中使用。不十分熟悉的读者，可以看看后面给出的小节。 同样，由于构造子是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处

理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

饿汉式单例类可以在Java 语言内实现， 但不易在C++ 内实现，因为静态初始化在C++ 里没有固定的顺序，因而静态的m_instance 变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么GoF 在提出单例类的概念时，举的例子是懒汉式的。他们的书影响之大，以致Java 语言中单例类的例子也大多是懒汉式的。实际上，本书认为饿汉式单例类更符合Java 语言本身的特点。

3.登记式单例类.

package pattern.singleton;

import java.util.HashMap;

import java.util.Map;

//登记式单例类.

//类似Spring里面的方法，将类名注册，下次从里面直接获取。

public class Singleton3 {

private static Map map = new HashMap();

static{

Singleton3 single = new Singleton3();

map.put(single.getClass().getName(), single);

}

//保护的默认构造子

protected Singleton3(){}

//静态工厂方法,返还此类惟一的实例

public static Singleton3 getInstance(String name) {

if(name == null) {

name = Singleton3.class.getName();

System.out.println("name == null"+"---name="+name);

}

if(map.get(name) == null) {

try {

map.put(name, (Singleton3) Class.forName(name).newInstance());

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

return map.get(name);

}

//一个示意性的商业方法

public String about() {

return "Hello, I am RegSingleton.";

}

public static void main(String[] args) {

Singleton3 single3 = Singleton3.getInstance(null);

System.out.println(single3.about());

}

}

java问题，servlet问题，servlet在什么时候被初始化？它是线程安全吗？

一、servlet的生命周期\x0d\x0a 1. servlet 有种初始化情形：\x0d\x0a a.在servlet容器启动时初始化。在web.xml 中配置1表示在容器启动时初始化。默认没有此置，表示另一种情形。\x0d\x0a b.servlet在第一次被访问时初始化。即创建唯一的servlet实例。（单例多线程下面会说）\x0d\x0a \x0d\x0a 初始化包括4个步骤：\x0d\x0a 1)servlet容器价值servlet类，把它的.class文件读入内存 \x0d\x0a 2)servlet容器创建ServletConfig对象。servletConfig对象包含特定的初始化配置信息，\x0d\x0a如s ervlet初始化参数，servlet还会是servletConfig与当前应用的ServletContext对象关联。 \x0d\x0a 3)servlet容器创建servlet对象\x0d\x0a 4)容器调用servlet对象的init(servletConfig config)方法，servlet创建完成。\x0d\x0a 2. 当有请求访问该servlet是，servlet容器就会创建针对于这个请求的servletRequest于servletResponse，然后\x0d\x0aservlet的service方法被调用。当容器把servlet生成的响应结果发送给客户，容器就会销毁request和response对象。\x0d\x0a 3. 容器在销毁该实例前调用servlet的destroy方法（释放servlet所占用的资源，如关闭流和数据库连接），此外还会销毁与servlet对象关联的ServletConfig对象。\x0d\x0a \x0d\x0a二、 servlet的线程安全\x0d\x0a 1. servlet类只创建一个实例，对于可与客户端的并发访问，它是线程不安全的。\x0d\x0a 2. servlet的处理方式是，每次访问时重新起一线程执行service方法。所以要想保证servlet的线程安全，不应该在servlet中定义实例变量。\x0d\x0a 3. 当然完全可以通过加锁保证线程安全，但对于成千上万的并发访问，性能下降。

求java大牛，关于单例模式的使用问题，小白真心求教

单例模式是Java23中设计模式中比较简单的一种，特点如下：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

一、懒汉式单例、

//懒汉式单例类.在第一次调用的时候实例化自己

public class Singleton {

private Singleton() {}

private static Singleton single=null;

//静态工厂方法

public static Singleton getInstance() {

if (single == null) {

single = new Singleton();

}

return single;

}

}

懒汉式单例模式是线程不安全的，请注意，关于线程安全由于篇幅问题可以自己百度。

二、饿汉式单例

//饿汉式单例类.在类初始化时，已经自行实例化

public class Singleton1 {

private Singleton1() {}

private static final Singleton1 single = new Singleton1();

//静态工厂方法

public static Singleton1 getInstance() {

return single;

}

}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

饿汉式和懒汉式区别

从名字上来说，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从以下两点再区分以下这两种方式：

1、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

望采纳！谢谢。

JAVA单例模式有哪些？

一、懒汉式单例\x0d\x0a在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。\x0d\x0a \x0d\x0apublic class LazySingleton {\x0d\x0a /**\x0d\x0a * 私有静态对象,加载时候不做初始化\x0d\x0a */\x0d\x0a private static LazySingleton m_intance=null;\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private LazySingleton(){\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例. \x0d\x0a * 当发现实例没有初始化的时候,才初始化.\x0d\x0a */\x0d\x0a synchronized public static LazySingleton getInstance(){\x0d\x0a if(m_intance==null){\x0d\x0a m_intance=new LazySingleton();\x0d\x0a }\x0d\x0a return m_intance;\x0d\x0a }\x0d\x0a}\x0d\x0a\x0d\x0a二、饿汉式单例\x0d\x0a在类被加载的时候，唯一实例已经被创建。\x0d\x0a \x0d\x0apublic class EagerSingleton {\x0d\x0a /**\x0d\x0a * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象\x0d\x0a */\x0d\x0a private static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private EagerSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例.\x0d\x0a * @return EagerSingleton\x0d\x0a */\x0d\x0a public static EagerSingleton getInstance() {\x0d\x0a return m_instance;\x0d\x0a }\x0d\x0a}\x0d\x0a \x0d\x0a************************************************************************************** 懒汉方式，指全局的单例实例在第一次被使用时构建； \x0d\x0a饿汉方式，指全局的单例实例在类装载时构建 \x0d\x0a**************************************************************************************\x0d\x0a\x0d\x0a三、登记式单例\x0d\x0a这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。\x0d\x0apublic class RegSingleton {\x0d\x0a /**\x0d\x0a * 登记薄,用来存放所有登记的实例\x0d\x0a */\x0d\x0a private static Map m_registry = new HashMap();\x0d\x0a //在类加载的时候添加一个实例到登记薄\x0d\x0a static {\x0d\x0a RegSingleton x = new RegSingleton();\x0d\x0a m_registry.put(x.getClass().getName(), x);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 受保护的默认构造方法\x0d\x0a */\x0d\x0a protected RegSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回指定登记对象的唯一实例;\x0d\x0a * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回\x0d\x0a * @param name\x0d\x0a * @return RegSingleton\x0d\x0a */\x0d\x0a public static RegSingleton getInstance(String name) {\x0d\x0a if (name == null) {\x0d\x0a name = "RegSingleton";\x0d\x0a }\x0d\x0a if (m_registry.get(name) == null) {\x0d\x0a try {\x0d\x0a m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());\x0d\x0a } catch (InstantiationException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (IllegalAccessException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (ClassNotFoundException e) {\x0d\x0a e.printStackTrace();\x0d\x0a }\x0d\x0a }\x0d\x0a return m_registry.get(name);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 一个示意性的商业方法\x0d\x0a * @return String\x0d\x0a */\x0d\x0a public String about() {\x0d\x0a return "Hello,I am RegSingleton!";\x0d\x0a }\x0d\x0a}

关于java单例初始化和java初始化语句的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。