Java开发中为什么要使用单例模式详解

一、什么是单例模式？

单例设计模式（singleton design pattern）理解起来非常简单。一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。

二、实战案例一：处理资源访问冲突

我们先来看第一个例子。在这个例子中，我们自定义实现了一个往文件中打印日志的 logger 类。具体的代码实现如下所示：

public class logger {
  private filewriter writer;
  
  public logger() {
    file file = new file("/users/wangzheng/log.txt");
    writer = new filewriter(file, true); //true表示追加写入
  }
  
  public void log(string message) {
    writer.write(mesasge);
  }
}

// logger类的应用示例：
public class usercontroller {
  private logger logger = new logger();
  
  public void login(string username, string password) {
    // ...省略业务逻辑代码...
    logger.log(username + " logined!");
  }
}

public class ordercontroller {
  private logger logger = new logger();
  
  public void create(ordervo order) {
    // ...省略业务逻辑代码...
    logger.log("created an order: " + order.tostring());
  }
}

看完代码之后，先别着急看我下面的讲解，你可以先思考一下，这段代码存在什么问题。

在上面的代码中，我们注意到，所有的日志都写入到同一个文件 /users/wangzheng/log.txt 中。在 usercontroller 和 ordercontroller 中，我们分别创建两个 logger 对象。在 web 容器的 servlet 多线程环境下，如果两个 servlet 线程同时分别执行 login() 和 create() 两个函数，并且同时写日志到 log.txt 文件中，那就有可能存在日志信息互相覆盖的情况。

为什么会出现互相覆盖呢？我们可以这么类比着理解。在多线程环境下，如果两个线程同时给同一个共享变量加 1，因为共享变量是竞争资源，所以，共享变量最后的结果有可能并不是加了 2，而是只加了 1。同理，这里的 log.txt 文件也是竞争资源，两个线程同时往里面写数据，就有可能存在互相覆盖的情况。

那如何来解决这个问题呢？我们最先想到的就是通过加锁的方式：给 log() 函数加互斥锁（java 中可以通过 synchronized 的关键字），同一时刻只允许一个线程调用执行 log() 函数。具体的代码实现如下所示：

public class logger {
  private filewriter writer;

  public logger() {
    file file = new file("/users/wangzheng/log.txt");
    writer = new filewriter(file, true); //true表示追加写入
  }
  
  public void log(string message) {
    synchronized(this) {
      writer.write(mesasge);
    }
  }
}

不过，你仔细想想，这真的能解决多线程写入日志时互相覆盖的问题吗？答案是否定的。这是因为，这种锁是一个对象级别的锁，一个对象在不同的线程下同时调用 log() 函数，会被强制要求顺序执行。但是，不同的对象之间并不共享同一把锁。在不同的线程下，通过不同的对象调用执行 log() 函数，锁并不会起作用，仍然有可能存在写入日志互相覆盖的问题。

我这里稍微补充一下，在刚刚的讲解和给出的代码中，我故意“隐瞒”了一个事实：我们给 log() 函数加不加对象级别的锁，其实都没有关系。因为 filewriter 本身就是线程安全的，它的内部实现中本身就加了对象级别的锁，因此，在外层调用 write() 函数的时候，再加对象级别的锁实际上是多此一举。因为不同的 logger 对象不共享 filewriter 对象，所以，filewriter 对象级别的锁也解决不了数据写入互相覆盖的问题。

那我们该怎么解决这个问题呢？实际上，要想解决这个问题也不难，我们只需要把对象级别的锁，换成类级别的锁就可以了。让所有的对象都共享同一把锁。这样就避免了不同对象之间同时调用 log() 函数，而导致的日志覆盖问题。具体的代码实现如下所示：

public class logger {
  private filewriter writer;

  public logger() {
    file file = new file("/users/wangzheng/log.txt");
    writer = new filewriter(file, true); //true表示追加写入
  }
  
  public void log(string message) {
    synchronized(logger.class) { // 类级别的锁
      writer.write(mesasge);
    }
  }
}

除了使用类级别锁之外，实际上，解决资源竞争问题的办法还有很多，分布式锁是最常听到的一种解决方案。不过，实现一个安全可靠、无 bug、高性能的分布式锁，并不是件容易的事情。除此之外，并发队列（比如 java 中的 blockingqueue）也可以解决这个问题：多个线程同时往并发队列里写日志，一个单独的线程负责将并发队列中的数据，写入到日志文件。这种方式实现起来也稍微有点复杂。

相对于这两种解决方案，单例模式的解决思路就简单一些了。单例模式相对于之前类级别锁的好处是，不用创建那么多 logger 对象，一方面节省内存空间，另一方面节省系统文件句柄（对于操作系统来说，文件句柄也是一种资源，不能随便浪费）

我们将 logger 设计成一个单例类，程序中只允许创建一个 logger 对象，所有的线程共享使用的这一个 logger 对象，共享一个 filewriter 对象，而 filewriter 本身是对象级别线程安全的，也就避免了多线程情况下写日志会互相覆盖的问题。

按照这个设计思路，我们实现了 logger 单例类。具体代码如下所示：

public class logger {
  private filewriter writer;
  private static final logger instance = new logger();

  private logger() {
    file file = new file("/users/wangzheng/log.txt");
    writer = new filewriter(file, true); //true表示追加写入
  }
  
  public static logger getinstance() {
    return instance;
  }
  
  public void log(string message) {
    writer.write(mesasge);
  }
}

// logger类的应用示例：
public class usercontroller {
  public void login(string username, string password) {
    // ...省略业务逻辑代码...
    logger.getinstance().log(username + " logined!");
  }
}

public class ordercontroller {  
  public void create(ordervo order) {
    // ...省略业务逻辑代码...
    logger.getinstance().log("created a order: " + order.tostring());
  }
}

三、实战案例二：表示全局唯一类

从业务概念上，如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。比如，配置信息类。在系统中，我们只有一个配置文件，当配置文件被加载到内存之后，以对象的形式存在，也理所应当只有一份。再比如，唯一递增 id 号码生成器，如果程序中有两个对象，那就会存在生成重复 id 的情况，所以，我们应该将 id 生成器类设计为单例。

import java.util.concurrent.atomic.atomiclong;
public class idgenerator {
  // atomiclong是一个java并发库中提供的一个原子变量类型,
  // 它将一些线程不安全需要加锁的复合操作封装为了线程安全的原子操作，
  // 比如下面会用到的incrementandget().
  private atomiclong id = new atomiclong(0);
  private static final idgenerator instance = new idgenerator();
  private idgenerator() {}
  public static idgenerator getinstance() {
    return instance;
  }
  public long getid() { 
    return id.incrementandget();
  }
}

// idgenerator使用举例
long id = idgenerator.getinstance().getid();

到此这篇关于java开发中为什么要使用单例模式详解的文章就介绍到这了,更多相关java单例模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！