单例设计模式java代码,实现单例设计模式
如何写一个标准的Java单例模式
一般Singleton模式通常有两种形式:第一种形式:也是常用的形式。publicclassSingleton{privatestaticSingletoninstance=null;privateSingleton(){//dosomething}//这个方法比下面的有所改进，不用每次都进行生成对象，只是第一次使用时生成实例，提高了效率publicstaticSingletongetInstance(){if(instance==null){instance=newSingleton();}returninstance;}}第二种形式:publicclassSingleton{//在自己内部定义自己的一个实例，只供内部调用privatestaticSingletoninstance=newSingleton();privateSingleton(){//dosomething}//这里提供了一个供外部访问本class的静态方法，可以直接访问publicstaticSingletongetInstance(){returninstance;}}
创新互联-专业网站定制、快速模板网站建设、高性价比屏南网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式屏南网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖屏南地区。费用合理售后完善，10多年实体公司更值得信赖。
java中的单例模式的代码怎么写
我从我的博客里把我的文章粘贴过来吧，对于单例模式模式应该有比较清楚的解释：
单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。
一般说来，单例模式通常有以下几种：
1.饥汉式单例
public class Singleton {
private Singleton(){};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
这是最简单的单例，这种单例最常见，也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时，单例就会被加载到内存中。
在这里我们可以做个这样的测试：
将上述代码修改为：
public class Singleton {
private Singleton(){
System.out.println("createSingleton");
};
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）
public class TestSingleton {
@Test
public void test(){
Singleton.testSingleton();
}
}
输出结果：
createSingleton
CreateString
我们可以注意到，在这个单例中，即使我们没有使用单例类，它还是被创建出来了，这当然是我们所不愿意看到的，所以也就有了以下一种单例。
2.懒汉式单例
public class Singleton1 {
private Singleton1(){
System.out.println("createSingleton");
}
private static Singleton1 instance = null;
public static synchronized Singleton1 getInstance(){
return instance==null?new Singleton1():instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
上面的单例获取实例时，是需要加上同步的，如果不加上同步，在多线程的环境中，当线程1完成新建单例操作，而在完成赋值操作之前，线程2就可能判
断instance为空，此时，线程2也将启动新建单例的操作，那么多个就出现了多个实例被新建，也就违反了我们使用单例模式的初衷了。
我们在这里也通过一个测试类，对它进行测试，最后面输出是
CreateString
可以看出，在未使用到单例类时，单例类并不会加载到内存中，只有我们需要使用到他的时候，才会进行实例化。
这种单例解决了单例的延迟加载，但是由于引入了同步的关键字，因此在多线程的环境下，所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。
public class TestSingleton {
@Test
public void test(){
long beginTime1 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton.getInstance();
}
System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));
long beginTime2 = System.currentTimeMillis();
for(int i=0;i100000;i++){
Singleton1.getInstance();
}
System.out.println("单例2花费时间："+(System.currentTimeMillis()-beginTime2));
}
}
最后输出的是：
单例1花费时间：0
单例2花费时间：10
可以看到，使用第一种单例耗时0ms，第二种单例耗时10ms，性能上存在明显的差异。为了使用延迟加载的功能，而导致单例的性能上存在明显差异，
是不是会得不偿失呢？是否可以找到一种更好的解决的办法呢？既可以解决延迟加载，又不至于性能损耗过多，所以，也就有了第三种单例：
3.内部类托管单例
public class Singleton2 {
private Singleton2(){}
private static class SingletonHolder{
private static Singleton2 instance=new Singleton2();
}
private static Singleton2 getInstance(){
return SingletonHolder.instance;
}
}
在这个单例中，我们通过静态内部类来托管单例，当这个单例被加载时，不会初始化单例类，只有当getInstance方法被调用的时候，才会去加载
SingletonHolder，从而才会去初始化instance。并且，单例的加载是在内部类的加载的时候完成的，所以天生对线程友好，而且也不需要
synchnoized关键字，可以说是兼具了以上的两个优点。
4.总结
一般来说，上述的单例已经基本可以保证在一个系统中只会存在一个实例了，但是，仍然可能会有其他的情况，导致系统生成多个单例，请看以下情况：
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
通过一段代码来测试：
@Test
public void test() throws Exception{
Singleton3 s1 = null;
Singleton3 s2 = Singleton3.getInstance();
//1.将实例串行话到文件
FileOutputStream fos = new FileOutputStream("singleton.txt");
ObjectOutputStream oos =new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
//2.从文件中读取出单例
FileInputStream fis = new FileInputStream("singleton.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (Singleton3) ois.readObject();
if(s1==s2){
System.out.println("同一个实例");
}else{
System.out.println("不是同一个实例");
}
}
输出：
不是同一个实例
可以看到当我们把单例反序列化后，生成了多个不同的单例类，此时，我们必须在原来的代码中加入readResolve()函数，来阻止它生成新的单例
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance = new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
//阻止生成新的实例
public Object readResolve(){
return SingletonHolder.instance;
}
}
再次测试时，就可以发现他们生成的是同一个实例了。
在Java中，单例设计模式是什么意思？有什么优势？
单例模式：保证一个类在使用过程中，只有一个实例。
优势就是单例模式的作用，这个类永远只有一个实例。
还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收。
java的学习建议:
首先要看书读理论，不一定都懂，因为有一个懂的过程；
然后就是分析代码，看看书上的代码的意思，逐行逐行地看，去体会；
最重要的一点就是敲写代码，刚开始不会没关系，照着书一行一行的敲，然后运行，观察结果，把程序运行结果联系程序代码，学得多一点了就尝试修改代码，改一点点看运行结果有什么变化，便于理解程序内部执行的机制。
JAVA 采用单例设计模式设计日志处理类，并写出代码
import java.util.Date;
public class Logger {
private static Logger instance;
private static Class clazz;
private Logger() {
}
private Logger(Class clazz) {
this.instance = new Logger();
this.clazz = clazz;
}
public static Logger getLogger(Class clazz) {
if (instance == null) {
synchronized (Logger.class) {
if (instance == null) {
instance = new Logger(clazz);
}
}
}
return instance;
}
public void info(String msg) {
System.out.println(clazz.getName() + "[" + new Date().toLocaleString()
+ "][info]:" + msg);
}
public void error(String msg) {
System.out.println(clazz.getName() + "[" + new Date().toLocaleString()
+ "][error]:" + msg);
}
public void warn(String msg) {
System.out.println(clazz.getName() + "[" + new Date().toLocaleString()
+ "][warn]:" + msg);
}
public void log(String msg) {
System.out.println(clazz.getName() + "[" + new Date().toLocaleString()
+ "][log]:" + msg);
}
public static void main(String args[]) {
Logger s = Logger.getLogger(String.class);
s.info("普通消息");
}
}
文章名称：单例设计模式java代码,实现单例设计模式
新闻来源：http://shouzuofang.com/article/dscpije.html