单例模式的练习-如何正确构建

最新推荐文章于 2022-06-29 21:41:04 发布
最新推荐文章于 2022-06-29 21:41:04 发布
阅读量108 收藏
点赞数
文章标签： java python 设计模式
原文链接：https://my.oschina.net/20076678/blog/80585
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

１、说明：单例模式是最简单的设计模式之一，单例模式适合于一个类只有一个实例的情况。

２、要求：确保一个类只有一个实例被建立，并提供了一个对对象的全局访问指针 。

３、注意事项：如何正确构建线程安全的单例模式。

不正确的构建，示例代码加测试代码如下： 


package org.com.jsoup;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPublicTest {

	public static   ThreadPublicTest test   ;

	private final String threadName;

	private ThreadPublicTest() {
		System.out.println("构建方法执行，当前执行线程名称为：" +　Thread.currentThread().getName());
threadName = Thread.currentThread().getName();
	}

	public String getThreadName() {
		return threadName;
	}

	public static   ThreadPublicTest getThreadPublicTest() {
		if (test == null){
			test = new ThreadPublicTest();
		}
		return test;
	}

	/**
	 * @param args测试代码
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		// 开始时间
		long beginTime = System.nanoTime();

		final int theadMax = 10;
		final CyclicBarrier cyclicBarrier = new CyclicBarrier(theadMax);
		// 创建一个线程池,限制为最多theadMax个线程
		final ExecutorService exec = Executors.newFixedThreadPool(theadMax);
		// 创建锁存器，设置为theadMax个，表示要等待theadMax个线程执行完
		final CountDownLatch downLatch = new CountDownLatch(theadMax);
		for (int i = 0; i < theadMax; i++) {
			Runnable runable = new Runnable() {
				@Override
				public void run() {
					try {
						// 排队等待
						cyclicBarrier.await();
						ThreadPublicTest test = ThreadPublicTest
								.getThreadPublicTest();
						System.out.println(String.format("对象名称：%s　线程名称：%s",
								test.getThreadName(),Thread.currentThread().getName()));
					} catch (Exception e) {
						// 处理异常
					} finally {
						// 减少计数值
						downLatch.countDown();
					}
				}
			};
			// 将任务放入线程池执行
			exec.execute(runable);
		}
		downLatch.await();// 等待所有的并发访问完
		exec.shutdown();// 关闭线程池
		System.out.println("执行完毕:" + (System.nanoTime() - beginTime));
	}

}


上面的测试代码输出为：


构建方法执行，当前执行线程名称为：pool-1-thread-1

构建方法执行，当前执行线程名称为：pool-1-thread-10

对象名称：pool-1-thread-10　线程名称：pool-1-thread-4

对象名称：pool-1-thread-10　线程名称：pool-1-thread-10

对象名称：pool-1-thread-10　线程名称：pool-1-thread-2

对象名称：pool-1-thread-10　线程名称：pool-1-thread-8

对象名称：pool-1-thread-10　线程名称：pool-1-thread-6

对象名称：pool-1-thread-1　线程名称：pool-1-thread-1

对象名称：pool-1-thread-10　线程名称：pool-1-thread-5

对象名称：pool-1-thread-10　线程名称：pool-1-thread-3

对象名称：pool-1-thread-10　线程名称：pool-1-thread-7

对象名称：pool-1-thread-10　线程名称：pool-1-thread-9

执行完毕:57840462

说明这个对象的构造方法执行了多次，于是这不是线程安全的。

线程安全的构造方式１,示例代码加测试代码如下： 
package org.com.jsoup;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPublicTest {

	public static  final ThreadPublicTest test  = new ThreadPublicTest() ;

	private final String threadName;

	private ThreadPublicTest() {
		System.out.println("构建方法执行，当前执行线程名称为：" +  Thread.currentThread().getName());
		threadName = Thread.currentThread().getName();
	}

	public String getThreadName() {
		return threadName;
	}

	public static   ThreadPublicTest getThreadPublicTest() {
		return test;
	}

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		// 开始时间
		long beginTime = System.nanoTime();

		final int theadMax = 10;
		final CyclicBarrier cyclicBarrier = new CyclicBarrier(theadMax);
		// 创建一个线程池,限制为最多theadMax个线程
		final ExecutorService exec = Executors.newFixedThreadPool(theadMax);
		// 创建锁存器，设置为theadMax个，表示要等待theadMax个线程执行完
		final CountDownLatch downLatch = new CountDownLatch(theadMax);
		for (int i = 0; i < theadMax; i++) {
			Runnable runable = new Runnable() {
				@Override
				public void run() {
					try {
						// 排队等待
						cyclicBarrier.await();
						ThreadPublicTest test = ThreadPublicTest
								.getThreadPublicTest();
						System.out.println(String.format("对象名称：%s　线程名称：%s",
								test.getThreadName(),Thread.currentThread().getName()));
					} catch (Exception e) {
						// 处理异常
					} finally {
						// 减少计数值
						downLatch.countDown();
					}
				}
			};
			// 将任务放入线程池执行
			exec.execute(runable);
		}
		downLatch.await();// 等待所有的并发访问完
		exec.shutdown();// 关闭线程池
		System.out.println("执行完毕:" + (System.nanoTime() - beginTime));
	}

}


看看执行结果：
构建方法执行，当前执行线程名称为：main
对象名称：main　线程名称：pool-1-thread-1
对象名称：main　线程名称：pool-1-thread-6
对象名称：main　线程名称：pool-1-thread-2
对象名称：main　线程名称：pool-1-thread-4
对象名称：main　线程名称：pool-1-thread-8
对象名称：main　线程名称：pool-1-thread-10
对象名称：main　线程名称：pool-1-thread-3
对象名称：main　线程名称：pool-1-thread-5
对象名称：main　线程名称：pool-1-thread-7
对象名称：main　线程名称：pool-1-thread-9

执行完毕:51450575

可以看到构建方法只执行了一次，这种实现方法的好处是代码简洁，线程获取单例的方法执行效率高，缺点就是代码一加载就会执行对象初始化，所以上面我们看到构造方法是在主线程中执行的。

那么我们采用线程同步的方式来实现延迟初始化，以下是示例加测试代码： 


package org.com.jsoup;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPublicTest {

	public static   ThreadPublicTest test  ;

	private final String threadName;

	private ThreadPublicTest() {
		System.out.println("构建方法执行，当前执行线程名称为：" +  Thread.currentThread().getName());
		threadName = Thread.currentThread().getName();
	}

	public String getThreadName() {
		return threadName;
	}

	public static  synchronized ThreadPublicTest getThreadPublicTest() {
		if (test == null){
			test	= new ThreadPublicTest() ;
		}
		return test;
	}

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		// 开始时间
		long beginTime = System.nanoTime();

		final int theadMax = 10;
		final CyclicBarrier cyclicBarrier = new CyclicBarrier(theadMax);
		// 创建一个线程池,限制为最多theadMax个线程
		final ExecutorService exec = Executors.newFixedThreadPool(theadMax);
		// 创建锁存器，设置为theadMax个，表示要等待theadMax个线程执行完
		final CountDownLatch downLatch = new CountDownLatch(theadMax);
		for (int i = 0; i < theadMax; i++) {
			Runnable runable = new Runnable() {
				@Override
				public void run() {
					try {
						// 排队等待
						cyclicBarrier.await();
						ThreadPublicTest test = ThreadPublicTest
								.getThreadPublicTest();
						System.out.println(String.format("对象名称：%s　线程名称：%s",
								test.getThreadName(),Thread.currentThread().getName()));
					} catch (Exception e) {
						// 处理异常
					} finally {
						// 减少计数值
						downLatch.countDown();
					}
				}
			};
			// 将任务放入线程池执行
			exec.execute(runable);
		}
		downLatch.await();// 等待所有的并发访问完
		exec.shutdown();// 关闭线程池
		System.out.println("执行完毕:" + (System.nanoTime() - beginTime));
	}

}


看看测试的执行结果：


构建方法执行，当前执行线程名称为：pool-1-thread-10

对象名称：pool-1-thread-10　线程名称：pool-1-thread-5

对象名称：pool-1-thread-10　线程名称：pool-1-thread-1

对象名称：pool-1-thread-10　线程名称：pool-1-thread-10

对象名称：pool-1-thread-10　线程名称：pool-1-thread-4

对象名称：pool-1-thread-10　线程名称：pool-1-thread-7

对象名称：pool-1-thread-10　线程名称：pool-1-thread-6

对象名称：pool-1-thread-10　线程名称：pool-1-thread-3

对象名称：pool-1-thread-10　线程名称：pool-1-thread-8

对象名称：pool-1-thread-10　线程名称：pool-1-thread-9

对象名称：pool-1-thread-10　线程名称：pool-1-thread-2

执行完毕:44952622

上面的执行结果表明单例对象是在子线程中执行的，好处就是，系统要用到单例对象时才构造，避免不使用也进行构造而浪费内存，缺点就是线程获取这个单例对象时每次都要判断并加了synchronized进行线程同步，执行效率稍低。

还有更好的方法吗？或许下面的示例可以（延长初始化点位类模式）： 
package org.com.jsoup;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPublicTest {
	
	private static class InternalHalder{
		//JVM会根据需要的时候才会初始化ThreadPublicTest
		public static final ThreadPublicTest test = new ThreadPublicTest();
	}
	public static   ThreadPublicTest test  ;

	private final String threadName;

	private ThreadPublicTest() {
		System.out.println("构建方法执行，当前执行线程名称为：" +  Thread.currentThread().getName());
		threadName = Thread.currentThread().getName();
	}

	public String getThreadName() {
		return threadName;
	}

	public static  ThreadPublicTest getThreadPublicTest() {
		return InternalHalder.test;
	}

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		// 开始时间
		long beginTime = System.nanoTime();

		final int theadMax = 10;
		final CyclicBarrier cyclicBarrier = new CyclicBarrier(theadMax);
		// 创建一个线程池,限制为最多theadMax个线程
		final ExecutorService exec = Executors.newFixedThreadPool(theadMax);
		// 创建锁存器，设置为theadMax个，表示要等待theadMax个线程执行完
		final CountDownLatch downLatch = new CountDownLatch(theadMax);
		for (int i = 0; i < theadMax; i++) {
			Runnable runable = new Runnable() {
				@Override
				public void run() {
					try {
						// 排队等待
						cyclicBarrier.await();
						ThreadPublicTest test = ThreadPublicTest
								.getThreadPublicTest();
						System.out.println(String.format("对象名称：%s　线程名称：%s",
								test.getThreadName(),Thread.currentThread().getName()));
					} catch (Exception e) {
						// 处理异常
					} finally {
						// 减少计数值
						downLatch.countDown();
					}
				}
			};
			// 将任务放入线程池执行
			exec.execute(runable);
		}
		downLatch.await();// 等待所有的并发访问完
		exec.shutdown();// 关闭线程池
		System.out.println("执行完毕:" + (System.nanoTime() - beginTime));
	}

}


执行结果跟上面一个示例是一样，但是不一样的是减少了同步开销，性能优于上一个。








转载于:https://my.oschina.net/20076678/blog/80585

weixin_34117211
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java单例模式练习
mine_
07-23 274
练习 一、选择 1、单例模式的实现必须满足（AC）个条件（多选） A. 类中的构造方法的访问权限必须设置为私有的 B. 类中的构造方法必须用protected修饰 C. 必须在类中创建该类的静态私有对象 D. 在类中提供一个公有的静态方法用于创建、获取静态私有对象 2、下列关于懒汉式和饿汉式的说法错误的是（多选）AB A. 饿汉式在第一次使用时进行实例化 B. 懒汉式在类加载时就创建实例 C. 饿汉式的线程是安全的 D. 懒汉式存在线程风险 二、编程 1、某公司研发星球维护系统，请使用饿汉式单例模式的实现思
Java单例模式(复习)
BIGBEAR的博客
01-25 243
单例模式的概念: 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例 Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。” Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
单例模式的练习
Bennettgxd的博客
09-16 127
单例模式 package com.bennett.test0916; public class Sigleton { // 饿汉模式 private static Sigleton instance=new Sigleton(); private Sigleton(){ } // （对象）工厂方法 // getSigleton // getInstace // getObject static Sigleton getInstace() { // 饱汉模式 if(instance==n
Java基础：单例模式练习
麦田
11-27 378
单例模式 单例也就是单个一个实例，单例模式也就是在程序运行过程中，单例模式设计的类只会出现一个实例。因为创建对象都是要调用构造函数的，所以每一种单例模式的第一步都是将构造函数私有化。 懒汉模式 懒汉模式表示不会提前创建好对象的实例，而是在需要到此类对象时才去创建。 私有化构造函数，使其在外部无法创建对象。 提供对外的获得此类对象的接口（getA方法）。 创建一个静态的全局本类类型属性，之所以是静态的，是因为只会创建一次，只有一个空间。 为了防备外部直接调用静态的属性而获得此类对象，需要将全局属性私有化。
5. Java单例模式练习
CoderJoana的博客
12-04 163
5. Java单例模式练习 一、选择 单例模式的实现必须满足（）个条件（多选）ACD A. 类中的构造方法的访问权限必须设置为私有的 B. 类中的构造方法必须用protected修饰 C. 必须在类中创建该类的静态私有对象 D. 在类中提供一个公有的静态方法用于创建、获取静态私有对象 下列关于懒汉式和饿汉式的说法错误的是（多选）AB A. 饿汉式在第一次使用时进行实例化 B. 懒汉式在类加载时就创建实例 C. 饿汉式的线程是安全的 D. 懒汉式存在线程风险 二、编程 某公司研发星
my-exercise:练习代码
03-21
7. **设计模式**：设计模式是解决常见编程问题的最佳实践，如单例模式、工厂模式、观察者模式等，通过实践可以提升代码复用性和可维护性。 8. **泛型**：Java的泛型提供了类型安全的容器，可以避免在运行时出现类型...
maven-text-demo:练习使用 反射- 注解 -过滤器-线程池--设计模式
05-10
常见的设计模式包括工厂模式、单例模式、建造者模式、观察者模式、装饰者模式等。在Java中，设计模式可以帮助我们编写可读性更强、可维护性更好、易于扩展的代码。 在这个"maven-text-demo"项目中，你将有机会实践...
HeadFirst设计模式
04-23
1. **单例模式（Singleton）**：确保一个类只有一个实例，并提供全局访问点。在多线程环境下，需要正确实现同步控制以防止多个实例的创建。书中通过“饿汉式”和“懒汉式”两种实现方式来阐述这个模式。 2. **工厂...
华为OD-java工程师机试103道习题练习
最新发布
05-02
12. **设计模式**：包括工厂模式、单例模式、观察者模式等，是解决常见问题的成熟方案，也是面试中常问的内容。 最后，我们谈谈华为OD可能关注的Java应用： 13. **Java EE**：企业级Java应用，包含Servlet、JSP、...
random-exercises:用C＃进行的许多练习
03-07
C#中常见的设计模式，如工厂模式、单例模式、观察者模式等，都可能在练习中出现，以提升代码的可复用性和可维护性。 通过这些C#练习，无论是初学者还是有经验的开发者，都能加深对C#语言的理解，提高编程技能，为...
python单例模式练习
u013434475的博客
03-20 230
单例设计模式是怎么来的？ 单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。 在面向对象的程序设计中，当业务并发量非常大时，那么就会出现重复创建相同的对象，每创建一个对象就会开辟一块内存空间，而这些对象其实是一模一样的，那么有没有办法使用得内存对象只创建一...
单例设计模式的练习
Demo_3的博客
04-12 444
单例设计模式有关的知识点class A(object): def __init__(self): print("这是 init 方法") def __new__(cls): print("这是 new 方法") return object.__new__(cls) #返回的是一个实例了的对象 就是self__new__至少要有一个参数
单例模式习题
hgfhjtff的博客
05-11 1005
一、选择 单例模式的实现必须满足（）个条件（多选） A. 类中的构造方法的访问权限必须设置为私有的 B. 类中的构造方法必须用protected修饰 C. 必须在类中创建该类的静态私有对象 D. 在类中提供一个公有的静态方法用于创建、获取静态私有对象 ...
单例模式构建方式
weixin_41239845的博客
10-20 204
Java中单例模式的定义：一个类有且只有一个实例，并且自行实例化向整个系统提供 构建方式有两种： 懒汉方式：指全局的单例实例在第一次被使用时构建 public class Singleton{ private static Singleton instance = null; private Singleton(){ } public static Singleton getInsta...
Java单例模式——黑马训练营
Tmandroid的专栏
10-22 513
-------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.单例模式概念 单例模式确保某一个类只有一个实例。而且自行实例化并向整个系统提供这个实例。 2.单例模式的特点 2.1 单例类只能有一个实例。 2.2 单例类必须自己创建自己唯一实例。 2.3 单例类必须给所有其他对象提供这一实例。 3.单例模式的有两种 3.
单例模式笔记
zzw_17600691357的博客
03-31 189
/** * @ClassName LazySingleCase * @Description 单例 懒汉式 * @Author zhaozhenwei * @LastChangeDate 2022/3/31 17:40 * @Version v1.0 */ public class LazySingleCase { private LazySingleCase() {}; private static final LazySingleCase SINGLETON = ne
精讲设计模式-单例模式(Singleton模式)
咸鱼弟的博客
06-29 372
精讲设计模式——单例模式(Singleton模式)
设计模式练习--单例模式
lllzy的博客
05-23 1291
参 考：  http://www.runoob.com/design-pattern/singleton-pattern.html        单例模式（Singleton Pattern）属于创建型模式，是 Java 中最简单的设计模式之一。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问
单例模式-------习题
the_first_player的博客
05-11 566
练习 一、选择 单例模式的实现必须满足（AC ）个条件（多选） A. 类中的构造方法的访问权限必须设置为私有的 B. 类中的构造方法必须用protected修饰 C. 必须在类中创建该类的静态私有对象 D. 在类中提供一个公有的静态方法用于创建、获取静态私有对象 下列关于懒汉式和饿汉式的说法错误的是（多选）（A B ） A. 饿汉式在第一次使用时进行实例化 B. 懒汉式在类加载时就创建实例 C. 饿汉式的线程是安全的 D. 懒汉式存在线程风险 二、编程 某公司研发星球维护系统，请使用饿汉式单例模
下列单例模式说法不正确的是
05-13
这个说法是正确的，单例模式的构造函数需要是私有的，以确保只能通过单例模式提供的方法获取唯一的实例。 3. 单例模式需要实现 Cloneable 接口，以便复制对象。 这个说法不正确，单例模式的目的是确保只有一个对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值