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,线程安全,通过缩小加锁的范围提高效率