Java单例模式在多线程环境下的性能测试对比实验分析

Java设计模式之单例模式

单例模式顾名思义就是在内存只有一个实例，是一个比较常用的设计模式，在很多的应用场景都有使用。关于他的UML图，应用场景，优点和缺点我就不介绍了，可以参考别人的文章或者文献等。

实验目标：

- 验证几种单例模式是否线程安全

- 多线程条件下：传统技术实例化类的时间性能问题

- 多线程条件下：单例模式实例化类的时间性能问题

- 模拟场景进行实验的对比，用数据说话

单例模式模式之饿汉式 —线程安全

public class Singleton1{
private static final Singleton1 instance = new Singleton1();

/**
* 构造函数设成私有，只允许获取实例的方法调用
*/
private Singleton1(){

}
public static Singleton1 getInstance(){
return instance;
}
}

验证是否饿汉式线程安全

public class Client {
public static void main(String[] args) {
// TODO Auto-generated method stub
//开启100个线程获取对象实例
for(int i = 0;i<100;i++){
Person person = new Person();
person.start();
}
}
}
/**
* 模拟应用场景：例如：KTV房间里只有一个话筒：而且有很多人都要唱歌   多线程模拟多人拿起的话筒是不是一个话筒
*/
class Person extends Thread{
@Override
public void run(){
System.out.println("话筒的hashCode值:"+Singleton1.getInstance().hashCode());
}
}

结果如图所示

单利模式之懒汉模式 — 只做验证线程安全的那个

public class Singleton2 {

private static Singleton2 instance = null;

//构造函数私有
private Singleton2(){

}

//静态的获取对象实例的方法
public static synchronized Singleton2 getInstance(){
if(instance == null){
instance = new Singleton2();   //如果对象为null则新建，否则直接返回
}
return instance;
}

}

测试同上



单利模式之静态内部类

public class Singleton3 {

private static class SingletonHolder{
private static final Singleton3 instance = new Singleton3();
}

private Singleton3(){

}

//静态的获取对象实例的方法
public static final Singleton3 getInstance(){
return SingletonHolder.instance;
}
}

验证结果：线程安全



单例模式之双重校验锁

public class Singleton4 {

private volatile static Singleton4 instance;

//构造
private Singleton4(){

}

//静态的获取对象实例的方法
public static Singleton4 getInstance(){

// 两重判断， 第一重是为了避免不必要的同步，因为频繁的锁会降低系统的性能
// 第二重是在instance在null情况下才会创建实例
if(instance == null){
synchronized (Singleton4.class) {
if(instance == null){
instance = new Singleton4();
}
}
}

return instance;
}
}

测试结果：线程安全



单例模式之枚举：线程安全

public enum Singleton5 {

INSTANCE;
}

同理测试：结果线程安全

几种单例模式的时间消耗

package com.jinwen.singleton;

import java.util.concurrent.CountDownLatch;

public class Client {

private static int count = 100;       //规定的线程数
private static long jobCountPerThread = 1000L;      //每个线程作业数

public static void main(String[] args) throws InterruptedException{
// TODO Auto-generated method stub

test1();   // 饿汉式测试
test2();   //懒汉式
test3();   //静态内部类
test4();   //双重校验锁
test5();   //枚举
test6();   //在同一种情况下直接传统技术new一个对象出来
}

/**
* 饿汉式在多线程环境下的测试函数
*/
public static void test1() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton1 s1 = Singleton1.getInstance();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("饿汉式总消耗时间："+(endTime-startTime)+"ms");
}

/**
* 懒汉式  多线程环境下的测试
*/
public static void test2() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton2 s2 = Singleton2.getInstance();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("懒汉式总消耗时间："+(endTime-startTime)+"ms");
}

/**
* 静态内部类  多线程环境下的测试
*/
public static void test3() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton3 s3 = Singleton3.getInstance();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("静态内部类总消耗时间："+(endTime-startTime)+"ms");
}

/**
* 双重校验锁  多线程环境下的测试
*/
public static void test4() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton4 s4 = Singleton4.getInstance();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("双重校验锁总消耗时间："+(endTime-startTime)+"ms");
}

/**
* 枚举  多线程环境下的测试
*/
public static void test5() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton5 s5 = Singleton5.INSTANCE;
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("枚举总消耗时间："+(endTime-startTime)+"ms");
}

/**********************多线程环境下直接new一个对象********************************/

public static void test6() throws InterruptedException{

long startTime = System.currentTimeMillis();     //开始时间
final CountDownLatch countDownLatch = new CountDownLatch(count);

for(int i=0;i<count;i++){
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < jobCountPerThread; i++) {
Singleton s = new Singleton();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long endTime = System.currentTimeMillis();
System.out.println("传统技术直接new总的消耗时间："+(endTime-startTime)+"ms");
}

}

class Singleton{

public Singleton(){

}
}

/**
* 模拟应用场景：例如：KTV房间里只有一个话筒：而且有很多人都要唱歌   多线程模拟多人拿起的话筒是不是一个话筒
*/
class Person extends Thread{

@Override
public void run(){
//System.out.println("话筒的hashCode值:"+Singleton5.INSTANCE.hashCode());
}
}

测试结果：通过不断的调整的count和jobCountPerThread的数，通过不断的进行实验，相信大家应该获得和我相类似的结果

实验序号	线程数	作业数
1	10	100000
2	100	100000
3	200	100000
4	500	100000
5	1000	100000
6	10	10000
7	100	1000
8	1000	1000

实验结果如下图所示：



结果分析：当在一个线程中调用对象实例的次数越多，也就是JobCountPerThread越大，使用单例模式显然更好，当然懒汉单例模式除外，当线程数高，JobCountPerThread不高，也就是我们在实际生活高并发的情况，单例模式不会比传统的新建对象的性能好，当高并发情况下，大部分单例模式甚至会更差些。

总结：我们在学习的时候应该实事求是，严谨求学，模式只有在适合的场景下用对了才会发挥出更好的性能，否则情况可能会更差。最后，我还是学生，希望能有大神多多给我一些意见，指出不对的地方。

代码的地址：https://github.com/jinchen92/DesignPattern