单例模式代码举例(java语言版与go语言版)

JAVA语言版单例模式

//单例模式最好的一种方式
public enum SingletonObjectEnumSafety {
    INSTANCE;

    public void output() {
        System.out.println("我是SingletonObjectEnumSafety,单例模式最好的一种方式");
    }
}

//效率高，非线程安全，懒汉模式
public class SingletonObjectNonSafety {
    private static SingletonObjectNonSafety instance;

    private SingletonObjectNonSafety() {
    }

    public void output() {
        System.out.println("我是SingletonObjectNonSafety,效率高，非线程安全");
    }

    public static SingletonObjectNonSafety getInstance() {
        if (instance == null) {
            return new SingletonObjectNonSafety();
        }
        return instance;
    }
}

//线程安全，初始化的时候需要内存（浪费内存），饿汉模式
public class SingletonObjectSafety {
    private static SingletonObjectSafety instance = new SingletonObjectSafety();

    private SingletonObjectSafety() {
    }

    public void output() {
        System.out.println("我是SingletonObjectSafety,线程安全，初始化的时候需要内存（浪费内存");
    }

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

//线程安全，通过缩小加锁的范围提高效率（类加锁）
public class SingletonobjectSelectSynSafety {
    private static SingletonobjectSelectSynSafety instance;

    private SingletonobjectSelectSynSafety() {
    }

    public void output() {
        System.out.println("我是SingletonobjectSelectSynSafety,线程安全，通过缩小加锁的范围提高效率");
    }

    public static SingletonobjectSelectSynSafety getInstance() {
        if (instance == null) {
            synchronized (SingletonobjectSelectSynSafety.class) {
                if (instance == null) {
                    instance = new SingletonobjectSelectSynSafety();
                }
            }
        }
        return instance;
    }
}

//线程安全，效率低下(方法加锁)
public class SingletonObjectSynSafety {
    private static SingletonObjectSynSafety instance;

    private SingletonObjectSynSafety() {
    }

    public void output() {
        System.out.println("我是SingletonObjectSynSafety,线程安全，效率低下(方法加锁)");
    }

    public static synchronized SingletonObjectSynSafety getInstance() {
        if (instance == null) {
            return new SingletonObjectSynSafety();

        }
        return instance;
    }
}


public class SingletonPatterDemo {
    public static void main(String[] args) {
        SingletonObjectEnumSafety singletonObjectEnumSafety = SingletonObjectEnumSafety.INSTANCE;
        singletonObjectEnumSafety.output();

        SingletonObjectNonSafety singletonObjectNonSafety = SingletonObjectNonSafety.getInstance();
        singletonObjectNonSafety.output();

        SingletonObjectSafety singletonObjectSafety = SingletonObjectSafety.getInstance();
        singletonObjectSafety.output();

        SingletonObjectSynSafety singletonObjectSynSafety = SingletonObjectSynSafety.getInstance();
        singletonObjectSynSafety.output();

        SingletonobjectSelectSynSafety singletonobjectSelectSynSafety = SingletonobjectSelectSynSafety.getInstance();
        singletonobjectSelectSynSafety.output();
    }

输出结果：

我是SingletonObjectEnumSafety,单例模式最好的一种方式
我是SingletonObjectNonSafety,效率高，非线程安全
我是SingletonObjectSafety,线程安全，初始化的时候需要内存（浪费内存
我是SingletonObjectSynSafety,线程安全，效率低下(方法加锁)
我是SingletonobjectSelectSynSafety,线程安全，通过缩小加锁的范围提高效率

GO语言版单例模式

type singletObjectNonSafety struct {
}
func (this *singletObjectNonSafety) Output() {
	fmt.Println("我是SingletonObjectNonSafety,效率高，非线程安全")
}
var instanceNonSafety *singletObjectNonSafety
func GetInstanceNonSafety() *singletObjectNonSafety {
	if instanceNonSafety == nil {
		instanceNonSafety = &singletObjectNonSafety{}
	}
	return instanceNonSafety
}


type singletonObjectsafety struct {
}
func (this *singletonObjectsafety) Output() {
	fmt.Println("我是SingletonObjectSafety,线程安全，初始化的时候需要内存（浪费内存")
}
var instanceSafety *singletonObjectsafety = &singletonObjectsafety{}
func GetInstanceSafety() *singletonObjectsafety {
	return instanceSafety
}


type singletonObjectSelectSynSafety struct {
}
func (this *singletonObjectSelectSynSafety) Output() {
	fmt.Println("我是singletonObjectSelectSynSafety,线程安全，通过缩小加锁的范围提高效率")
}
var instanceSelectSynSafety *singletonObjectSelectSynSafety
var syn sync.Mutex
func GetInstanceSelectSynSafety() *singletonObjectSelectSynSafety {
	if instanceSelectSynSafety == nil {
		syn.Lock()
		defer syn.Unlock()
		if instanceSelectSynSafety == nil {
			instanceSelectSynSafety = &singletonObjectSelectSynSafety{}
		}
	}
	return instanceSelectSynSafety
}


type singletonObjectSynSafety struct {
}
func (this *singletonObjectSynSafety) Output() {
	fmt.Println("我是singletonObjectSynSafety,线程安全，效率低下(方法加锁)")
}
var instanceSysSafety *singletonObjectSynSafety
func GetInstanceSysSafety() *singletonObjectSynSafety {
	syn.Lock()
	defer syn.Unlock()
	if instanceSysSafety == nil {
		instanceSysSafety = &singletonObjectSynSafety{}
	}
	return instanceSysSafety
}


func main() {
	singletObjectNonSafety := singleton.GetInstanceNonSafety()
	singletObjectNonSafety.Output()

	singletObjectSafety := singleton.GetInstanceSafety()
	singletObjectSafety.Output()

	singletObjectSysSafety := singleton.GetInstanceSysSafety()
	singletObjectSysSafety.Output()

	singletObjectSelectSysSafety := singleton.GetInstanceSelectSynSafety()
	singletObjectSelectSysSafety.Output()
}

输出结果：

我是SingletonObjectNonSafety,效率高，非线程安全
我是SingletonObjectSafety,线程安全，初始化的时候需要内存（浪费内存
我是singletonObjectSynSafety,线程安全，效率低下(方法加锁)
我是singletonObjectSelectSynSafety,线程安全，通过缩小加锁的范围提高效率