andrew7676
- 浏览: 188210 次
- 性别:
- 来自: 北京
-
文章分类
- 全部博客 (321)
- eclipse (4)
- idea (2)
- Html (8)
- Css (14)
- Javascript (8)
- Jquery (6)
- Ajax Json (4)
- Bootstrap (0)
- EasyUI (0)
- Layui (0)
- 数据结构 (0)
- Java (46)
- DesPattern (24)
- Algorithm (2)
- Jdbc (8)
- Jsp servlet (13)
- Struts2 (17)
- Hibernate (11)
- Spring (5)
- S2SH (1)
- SpringMVC (4)
- SpringBoot (11)
- WebService CXF (4)
- Poi (2)
- JFreeChart (0)
- Shiro (6)
- Lucene (5)
- ElasticSearch (0)
- JMS ActiveMQ (3)
- HttpClient (5)
- Activiti (0)
- SpringCloud (11)
- Dubbo (6)
- Docker (0)
- MySQL (27)
- Oracle (18)
- Redis (5)
- Mybatis (11)
- SSM (1)
- CentOS (10)
- Ant (2)
- Maven (4)
- Log4j (7)
- XML (5)
最新评论
1. 创建型模式 (3) 单例模式
1. 饿汉式单例模式
2. 懒汉式单例模式
(1) 简单懒汉式单例模式
(2) 有间隔的懒汉式单例模式
3. 线程安全的懒汉式单例模式
(1) 使用同步锁机制synchronized
(2) 使用同步代码块
(3) 使用同步代码块(针对某些重要的代码进行单独的同步，而不是全部进行同步)
(4) 双检查锁机制单例(推荐)
4. 使用静态内置类实现单例模式
5. 序列化与反序列化的单例模式
(1) 未使用readResolve方法的单例模式
(2) 使用readResolve方法的单例模式
6. 使用static代码块实现模式
线程安全
7. 使用枚举数据类型实现单例模式
8. 完善使用enum枚举实现单例模式
补充说明
参照博客：https://blog.csdn.net/cselmu9/article/details/51366946
单例模式是为确保一个类只有一个实例，并为整个系统提供一个全局访问点的一种模式方法。
（1）在任何情况下，单例类永远只有一个实例存在
（2）单例需要有能力为整个系统提供这一唯一实例
1. 饿汉式单例模式
线程安全 饿汉式单例是指在方法调用前，实例就已经创建好了。
package com.andrew.pattern0101.singleton.modal01;
/**
* 1.饿汉式单例模式
* 线程安全
* 饿汉式单例是指在方法调用前，实例就已经创建好了。
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = new SingletonTest();
private SingletonTest(){};
public static SingletonTest getInstance() {
return instance;
}
}
package com.andrew.pattern0101.singleton.modal01;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
860588932 860588932 860588932 860588932 860588932 860588932 860588932 860588932 860588932 860588932
2. 懒汉式单例模式
(1) 简单懒汉式单例模式
线程可能不安全 懒汉式单例是指在方法调用获取实例时才创建实例。
package com.andrew.pattern0101.singleton.modal0201;
/**
* 2.懒汉式单例模式
* (1)简单懒汉式单例模式
* 线程可能不安全
* 懒汉式单例是指在方法调用获取实例时才创建实例。
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {}
public static SingletonTest getInstance() {
// 下面代码无法在多线程下保证实例的唯一性
if (null == instance) {
instance = new SingletonTest();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0201;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
257688302 1483688470 1483688470 1483688470 860588932 860588932 257688302 257688302 257688302 257688302
(2) 有间隔的懒汉式单例模式
线程不安全 懒汉式单例是指在方法调用获取实例时才创建实例。
package com.andrew.pattern0101.singleton.modal0202;
/**
* 2.懒汉式单例模式
* (2)有间隔的懒汉式单例模式
* 线程不安全
* 懒汉式单例是指在方法调用获取实例时才创建实例。
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {}
public static SingletonTest getInstance() {
// 下面代码无法在多线程下保证实例的唯一性
// 应当在创建实例之前可能会有一些准备性的耗时工作
// 但是仍然无法保证单例的线程安全
try {
if (null != instance) {
} else {
Thread.sleep(300);
instance = new SingletonTest();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0202;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
474695494 2030908035 194025646 313586000 2049977720 1483688470 644512395 257688302 1388138972 724219370
3. 线程安全的懒汉式单例模式
(1) 使用同步锁机制synchronized
线程安全 懒汉式单例是指在方法调用获取实例时才创建实例。 为了保证线程安全，要使用同步锁机制，在方法中声明synchronized关键字
package com.andrew.pattern0101.singleton.modal0301;
/**
* 3.线程安全的懒汉式单例模式
* (1)使用同步锁机制synchronized
* 线程安全
* 懒汉式单例是指在方法调用获取实例时才创建实例。
* 为了保证线程安全，要使用同步锁机制，在方法中声明synchronized关键字
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {}
public synchronized static SingletonTest getInstance() {
// 应当在创建实例之前可能会有一些准备性的耗时工作，并声明同步锁synchronized关键字
// 但是这种方法效率很低
try {
if (null != instance) {
} else {
Thread.sleep(300);
instance = new SingletonTest();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0301;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646
(2) 使用同步代码块
线程安全 懒汉式单例是指在方法调用获取实例时才创建实例。 为了保证线程安全，提高同步锁效率，使用同步代码块实现
package com.andrew.pattern0101.singleton.modal0302;
/**
* 3.线程安全的懒汉式单例模式
* (2)使用同步代码块
* 线程安全
* 懒汉式单例是指在方法调用获取实例时才创建实例。
* 为了保证线程安全，提高同步锁效率，使用同步代码块实现
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {}
public static SingletonTest getInstance() {
// 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率
try {
synchronized (SingletonTest.class) {
if (null != instance) {
} else {
Thread.sleep(300);
instance = new SingletonTest();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0302;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
257688302 257688302 257688302 257688302 257688302 257688302 257688302 257688302 257688302 257688302
(3) 使用同步代码块(针对某些重要的代码进行单独的同步，而不是全部进行同步)
线程可能不安全 懒汉式单例是指在方法调用获取实例时才创建实例。 为了保证线程安全，提高同步锁效率，使用同步代码块实现
package com.andrew.pattern0101.singleton.modal0303;
/**
* 3.线程安全的懒汉式单例
* (3)使用同步代码块(针对某些重要的代码进行单独的同步，而不是全部进行同步)
* 线程可能不安全
* 懒汉式单例是指在方法调用获取实例时才创建实例。
* 为了保证线程安全，提高同步锁效率，使用同步代码块实现
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {}
public static SingletonTest getInstance() {
try {
if (null != instance) {
} else {
Thread.sleep(300);
// 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率,但是只同步一部分
synchronized (SingletonTest.class) {
instance = new SingletonTest();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0303;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
2030908035 2049977720 474695494 860588932 1906199352 516266445 194025646 1388138972 724219370 313586000
(4) 双检查锁机制单例(推荐)
线程安全 <1>采用DCL的双检查锁机 <2>使用volatile关键字保其可见性
package com.andrew.pattern0101.singleton.modal0304;
/**
* 3.线程安全的懒汉式单例
* (4).双检查锁机制单例(推荐)
* <1>采用DCL的双检查锁机
* <2>使用volatile关键字保其可见性
* 线程安全
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
// 使用volatile关键字保其可见性
volatile private static SingletonTest instance = null;
private SingletonTest() {}
public static SingletonTest getInstance() {
try {
if (null != instance) {
} else {
Thread.sleep(300);
// 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率,但是只同步一部分
synchronized (SingletonTest.class) {
// 在实例化之前进行二次检查
if (null == instance) {
instance = new SingletonTest();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return instance;
}
}
package com.andrew.pattern0101.singleton.modal0304;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
1483688470 1483688470 1483688470 1483688470 1483688470 1483688470 1483688470 1483688470 1483688470 1483688470
4. 使用静态内置类实现单例模式
线程安全
package com.andrew.pattern0101.singleton.modal04;
/**
* 4.使用静态内置类实现单例模式
* 线程安全
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
// 内部类
private static class SingletonTestHandler{
private static SingletonTest instance = new SingletonTest();
}
private SingletonTest() {}
public static SingletonTest getInstance() {
return SingletonTestHandler.instance;
}
}
package com.andrew.pattern0101.singleton.modal04;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
1798105197 1798105197 1798105197 1798105197 1798105197 1798105197 1798105197 1798105197 1798105197 1798105197
5. 序列化与反序列化的单例模式
(1) 未使用readResolve方法的单例模式
线程不安全 序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样，说明反序列化后返回的对象是重新实例化的，单例被破坏了。
package com.andrew.pattern0101.singleton.modal0501;
import java.io.Serializable;
/**
* 5.序列化与反序列化的单例模式
* (1)未使用readResolve方法的单例模式
* 线程不安全
* 序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样，说明反序列化后返回的对象是重新实例化的，单例被破坏了
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest implements Serializable {
private static final long serialVersionUID = 1L;
// 内部类
private static class SingletonTestHandler{
private static SingletonTest instance = new SingletonTest();
}
private SingletonTest() {}
public static SingletonTest getInstance() {
return SingletonTestHandler.instance;
}
}
package com.andrew.pattern0101.singleton.modal0501;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SaveAndReadForSingleton {
public static void main(String[] args) {
SingletonTest singletonTest = SingletonTest.getInstance();
File file = new File("MySingleton.txt");
try {
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(singletonTest);
fos.close();
oos.close();
System.out.println(singletonTest.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
SingletonTest rsingletonTest = (SingletonTest) ois.readObject();
fis.close();
ois.close();
System.out.println(rsingletonTest.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
1028566121 455659002
(2) 使用readResolve方法的单例模式
线程不安全 readResolve方法在反序列化时会被调用，实现反序列化
package com.andrew.pattern0101.singleton.modal0502;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
* 5.序列化与反序列化的单例模式
* (2)使用readResolve方法的单例模式
* 线程不安全
* readResolve方法在反序列化时会被调用，实现反序列化
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest implements Serializable {
private static final long serialVersionUID = 1L;
// 内部类
private static class SingletonTestHandler{
private static SingletonTest instance = new SingletonTest();
}
private SingletonTest() {}
public static SingletonTest getInstance() {
return SingletonTestHandler.instance;
}
// 该方法在反序列化时会被调用，该方法不是接口定义的方法，有点儿约定俗成的感觉
protected Object readResolve() throws ObjectStreamException {
System.out.println("调用了readResolve方法！");
return SingletonTestHandler.instance;
}
}
package com.andrew.pattern0101.singleton.modal0502;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SaveAndReadForSingleton {
public static void main(String[] args) {
SingletonTest singletonTest = SingletonTest.getInstance();
File file = new File("MySingleton.txt");
try {
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(singletonTest);
fos.close();
oos.close();
System.out.println(singletonTest.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
SingletonTest rsingletonTest = (SingletonTest) ois.readObject();
fis.close();
ois.close();
System.out.println(rsingletonTest.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
1028566121 调用了readResolve方法！ 1028566121
6. 使用static代码块实现模式
线程安全
静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性的实现单例设计模。
package com.andrew.pattern0101.singleton.modal06;
/**
* 6.使用static代码块实现模式
* 线程安全
* 静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性的实现单例设计模。
*
* @author andrew
* @date 2018/04/23
*/
public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest(){};
static {
instance = new SingletonTest();
}
public static SingletonTest getInstance() {
return instance;
}
}
package com.andrew.pattern0101.singleton.modal06;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(SingletonTest.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
2049977720 2049977720 2049977720 2049977720 2049977720 2049977720 2049977720 2049977720 2049977720 2049977720
7. 使用枚举数据类型实现单例模式
线程安全 枚举enum和静态代码块的特性相似，在使用枚举时，构造方法会被自动调用。
package com.andrew.pattern0101.singleton.modal07;
/**
* 7.使用枚举数据类型实现单例模式
* 线程安全
* 枚举enum和静态代码块的特性相似，在使用枚举时，构造方法会被自动调用。
*
* @author andrew
* @date 2018/04/23
*/
public enum EnumFactory {
singletonFactory;
private SingletonTest instance;
private EnumFactory(){
// 枚举类的构造方法在类加载是被实例化
instance = new SingletonTest();
}
public SingletonTest getInstance(){
return instance;
}
}
class SingletonTest {
// 需要获实现单例的类，比如数据库连接Connection
public SingletonTest(){}
}
package com.andrew.pattern0101.singleton.modal07;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(EnumFactory.singletonFactory.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646
8. 完善使用enum枚举实现单例模式
线程安全 不暴露枚举类实现细节
package com.andrew.pattern0101.singleton.modal08;
/**
* 8.完善使用enum枚举实现单例模式
* 线程安全
* 不暴露枚举类实现细节
*
* @author andrew
* @date 2018/04/23
*/
public class ClassFactory {
private enum EnumSingletonTest {
singletonFactory;
private SingletonTest instance;
private EnumSingletonTest() {
// 枚举类的构造方法在类加载是被实例化
instance = new SingletonTest();
}
public SingletonTest getInstance(){
return instance;
}
}
public static SingletonTest getInstance(){
return EnumSingletonTest.singletonFactory.getInstance();
}
}
class SingletonTest {
// 需要获实现单例的类，比如数据库连接Connection
public SingletonTest(){};
}
package com.andrew.pattern0101.singleton.modal08;
public class ThreadTest extends Thread {
@Override
public void run() {
System.out.println(ClassFactory.getInstance().hashCode());
}
public static void main(String[] args) {
ThreadTest[] tts = new ThreadTest[10];
for (int i = 0; i < tts.length; i++) {
tts[i] = new ThreadTest();
}
for (int j = 0; j < tts.length; j++) {
tts[j].start();
}
}
}
194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646 194025646
总结：推荐使用 3.线程安全的懒汉式单例模式 (4) 双检查锁机制单例(推荐)
补充说明
参照博客：https://blog.csdn.net/cselmu9/article/details/51366946
分享到：
发表评论
-
3. 行为型模式 (11) 解释器模式
2018-11-08 10:39 3943. 行为型模式 (11) 解释器模式 解释器模式（In ... -
3. 行为型模式 (10) 中介者模式
2018-11-08 09:56 3703. 行为型模式 (10) 中介者模式 中介者模式（Me ... -
3. 行为型模式 (9) 访问者模式
2018-11-07 14:30 3703. 行为型模式 (9) 访问者模式 访问者模式（Vis ... -
3. 行为型模式 (8) 状态模式
2018-11-07 09:13 4553. 行为型模式 (8) 状态模式 状态模式（State ... -
3. 行为型模式 (7) 备忘录模式
2018-11-06 14:27 4333. 行为型模式 (7) 备忘录模式 备忘录模式（Mem ... -
3. 行为型模式 (6) 命令模式
2018-11-06 11:40 3823. 行为型模式 (6) 命令模式 命令模式（Comma ... -
3. 行为型模式 (5) 责任链模式
2018-11-06 09:40 4333. 行为型模式 (5) 责任链模式 责任链模式（Cha ... -
3. 行为型模式 (4) 迭代子模式
2018-11-05 14:23 3533. 行为型模式 (4) 迭代 ... -
3. 行为型模式 (3) 观察者模式
2018-11-02 16:17 4483. 行为型模式 (3) 观察者模式 当对象间存在一对多 ... -
3. 行为型模式 (2) 模板方法模式
2018-11-02 09:26 4183. 行为型模式 (2) 模板方法模式 在模板模式（Te ... -
3. 行为型模式 (1) 策略模式
2018-11-01 09:23 4393. 行为型模式 (1) 策略模式 在策略模式（Stra ... -
2. 结构型模式 (3) 代理模式
2018-10-29 11:26 3752. 结构型模式 (3) 代理模式 代理模式（Proxy ... -
2. 结构型模式 (7) 享元模式
2018-10-30 13:27 4142. 结构型模式 (7) 享元模式 享元模式（Flywe ... -
2. 结构型模式 (6) 组合模式
2018-10-30 09:50 3662. 结构型模式 (6) 组合模式 组合模式（Compo ... -
2. 结构型模式 (2) 装饰者模式
2018-10-29 09:30 4112. 结构型模式 (2) 装饰器模式 装饰器模式（Dec ... -
2. 结构型模式 (5) 桥接模式
2018-10-30 09:11 3952. 结构型模式 (5) 桥接模式 桥接（Bridge） ... -
2. 结构型模式 (4) 外观模式
2018-10-29 14:20 3502. 结构型模式 (4) 外观模式 外观模式（Fac ... -
2. 结构型模式 (1) 适配器模式
2018-10-26 15:35 3852. 结构型模式 (1) 适配器模式 将一个类的接口转换 ... -
1. 创建型模式 (2) 原型模式
2018-09-12 13:46 7441. 创建型模式 (2) 原型模式 用原型实例指定创建对 ... -
1. 创建型模式 (3) 建造者模式
2018-10-25 16:28 3731. 创建型模式 (3) 建造 ...
相关推荐
1. 单例模式：单例模式确保一个类只有一个实例，并提供一个全局访问点。它在多线程环境中尤为重要，因为需要保证线程安全的单个实例创建。在Java等语言中，通常使用双检锁（Double-Check Locking）或者静态内部类的...
单例模式是软件设计模式中的一种，属于创建型模式。单例模式的目的是确保一个类在任何时候都只有一个实例，并且提供一个全局访问点给外部程序使用。 ## 单例模式的定义 单例模式是一种常用的软件设计模式，通过单例...
"设计模式单例模式和工厂模式综合应用"的主题聚焦于两种常用的设计模式：单例模式和工厂模式，并探讨它们如何协同工作来实现高效、灵活的代码结构。这个主题尤其适用于Java编程语言，因为Java的面向对象特性使得设计...
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，当创建对象时，我们不会对客户端暴露创建逻辑，而是提供一个接口来让客户端请求特定类型的实例。这样，客户端无需知道具体的产品实现...
1.创建型模式：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。 2.结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 4.行为型模式：模板方法模式、命令模式、...
JAVA-设计模式-创建型模式-单例模式
单例模式是软件设计模式中的一种，属于创建型模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下都非常有用，例如管理共享资源、配置对象或者缓存服务等。 单例模式的核心...
单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景中都是非常有用的，比如日志对象、配置管理器、线程池等。 ...
单例模式是软件设计模式中的一种，属于创建型模式，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在系统中需要频繁创建和销毁对象，且对象需要共享资源时非常适用，比如线程池、数据库连接...
单例设计模式是一种在软件设计中广泛使用的设计模式，它属于创建型模式，其核心目标是确保类只有一个实例，并提供一个全局访问点。这个模式在Java中尤其常见，因为Java的垃圾回收机制允许对象长时间驻留在内存中，...
工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪个类。这使得系统可以在不指定具体类的情况下引用抽象。在Java中，工厂模式可以通过定义一个工厂接口和多个实现了该接口的具体...
单例模式(Singleton Pattern)作为一种最基本的创建型设计模式，其主要目的是控制一个类的实例化过程，确保在整个应用程序中仅存在一个实例，并且该实例能够被全局访问。这种模式在实际软件开发中有着极其广泛的应用...
本篇文章将深入探讨如何在Java中实现单例模式，以及如何创建一个工具类来封装单例的创建。 首先，让我们了解单例模式的几种常见实现方式： 1. 饿汉式（静态常量）： 这是最简单的单例实现，它在类加载时就完成了...
单例模式是一种常用的创建型设计模式，它的主要目的是确保某个类只有一个实例，并且提供一个全局访问点来获取该实例。这种模式适用于系统中只需要一个实例的情况，例如日志记录器、配置管理等。 #### 三、单例模式...
【设计模式之创建型模式实验】 创建型设计模式主要关注对象的创建，它们提供了一种在不指定具体类的情况下创建对象的方式，增强了系统的灵活性和可扩展性。在本实验中，我们将探讨五种常见的创建型设计模式：简单...
本资源“一例读懂设计模式-单例模式、简单工厂模式.zip”旨在帮助初学者通过实例深入理解这两种重要设计模式：单例模式和简单工厂模式。以下是关于这两个模式的详细讲解。 1. **单例模式**： 单例模式是一种限制类...
单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这样做的好处在于，当系统只需要一个共享资源时，可以避免多次实例化导致的资源浪费，同时方便对这个唯一实例进行控制和管理。 ...
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，当创建对象时，不会直接实例化对象，而是通过一个专门的工厂类来创建。工厂类可以根据提供的参数来决定创建哪种类型的实例。 在 ...
1. **简单工厂模式**：这是一种创建型设计模式，它提供了一个静态方法来创建对象，而无需暴露实例化逻辑。简单工厂模式适用于对象创建相对固定且不需经常修改的情况。工厂类负责创建对象，客户端通过调用工厂的静态...