Java 单例模式探讨

深入探讨Java中的单例模式及多线程问题 本文深入探讨了Java编程中的单例模式,特别是在多线程环境下如何保证单例模式的正确实现。文章详细解释了通过同步方法解决多线程问题的原理,提出了几种不同的实现策略,并讨论了每种策略的优缺点和适用场景。 阅读详情

牛人的博客,必须研究 :  http://blog.youkuaiyun.com/it_man/article/details/5787567#comments


以下是我再次研究单例(java 单例模式缺点)时在网上收集的资料,相信你们看完就对单例完全掌握了

Java单例模式应该是看起来以及用起来简单的一种设计模式,但是就实现方式以及原理来说,也并不浅显哦。

 

总结一下我所知道的单例模式实现方式:

 

1.预先加载法

 

Java代码
  1. class S1 {   
  2.     private S1() {   
  3.         System.out.println("ok1");   
  4.     }   
  5.   
  6.   
  7.     private static S1 instance = new S1();   
  8.   
  9.     public static S1 getInstance() {   
  10.         return instance;   
  11.     }   
  12. }  
  1. class S1 {  
  2.     private S1() {  
  3.         System.out.println("ok1");  
  4.     }  
  5.   
  6.   
  7.     private static S1 instance = new S1();  
  8.   
  9.     public static S1 getInstance() {  
  10.         return instance;  
  11.     }  
  12. }  

 

优点: 

1.线程安全的

2.在类加载的同时已经创建好一个静态对象,调用时反应速度快。

缺点: 资源利用效率不高,可能getInstance永远不会执行到,但是执行了该类的其他静态方法或者加载了该类(class.forName),那么这个实例仍然初始化了

 


2.initialization on demand,延迟加载法  (考虑多线程)

 

Java代码
  1. class S2 {   
  2.     private S2() {   
  3.         System.out.println("ok2");   
  4.     }   
  5.   
  6.     private static S2 instance = null;   
  7.   
  8.     public static synchronized S2 getInstance() {   
  9.         if (instance == null) instance = new S2();   
  10.         return instance;   
  11.     }   
  12. }  
  1. class S2 {  
  2.     private S2() {  
  3.         System.out.println("ok2");  
  4.     }  
  5.   
  6.     private static S2 instance = null;  
  7.   
  8.     public static synchronized S2 getInstance() {  
  9.         if (instance == null) instance = new S2();  
  10.         return instance;  
  11.     }  
  12. }  

 

优点:资源利用率高,不执行getInstance就不会被实例,可以执行该类其他静态方法。


缺点: 第一次加载时发应不快  ,多线程使用不必要的同步开销大

 

3.initialization on demand double check 双重检测(考虑多线程)

 

Java代码
  1. class S3 {   
  2.     private S3() {   
  3.         System.out.println("ok3");   
  4.     }   
  5.   
  6.     private static S3 instance = null;   
  7.   
  8.     public static S3 getInstance() {   
  9.         if (instance == null) {   
  10.             synchronized (S3.class) {   
  11.                 if (instance == null)   
  12.                     instance = new S3();   
  13.             }   
  14.         }   
  15.         return instance;   
  16.     }   
  17. }  
  1. class S3 {  
  2.     private S3() {  
  3.         System.out.println("ok3");  
  4.     }  
  5.   
  6.     private static S3 instance = null;  
  7.   
  8.     public static S3 getInstance() {  
  9.         if (instance == null) {  
  10.             synchronized (S3.class) {  
  11.                 if (instance == null)  
  12.                     instance = new S3();  
  13.             }  
  14.         }  
  15.         return instance;  
  16.     }  
  17. }  

 

优点:资源利用率高, 不执行getInstance就不会被实例,可以执行该类其他静态方法。


缺点: 第一次加载时发应不快  ,由于java 内存模型一些原因偶尔会失败

 


4.initialization on demand holder  (考虑多线程)

 

Java代码
  1. class S4 {   
  2.     private S4() {   
  3.         System.out.println("ok4");   
  4.     }   
  5.   
  6.     private static class S4Holder {   
  7.         static S4 instance = new S4();   
  8.     }   
  9.   
  10.   
  11.     public static S4 getInstance() {   
  12.         return S4Holder.instance;   
  13.     }   
  14. }  
  1. class S4 {  
  2.     private S4() {  
  3.         System.out.println("ok4");  
  4.     }  
  5.   
  6.     private static class S4Holder {  
  7.         static S4 instance = new S4();  
  8.     }  
  9.   
  10.   
  11.     public static S4 getInstance() {  
  12.         return S4Holder.instance;  
  13.     }  
  14. }  

 

优点:资源利用率高, 不执行getInstance就不会被实例,可以执行该类其他静态方法。


缺点: 第一次加载时发应不快

 

 

 

总结:一般采用 1 即可,若对资源十分在意也可考虑 4 ,不要使用2,3了。

 

 

测试代码:(暂不探讨Class.forName类加载机制)

 

Java代码
  1. /**  
  2.  * Created by IntelliJ IDEA. 
  3.  * User: yiminghe  
  4.  * Date: 2009-6-8  
  5.  * Time: 19:20:52  
  6.  */  
  7. public class Singleton {   
  8.     public static void main(String[] args) throws Exception{   
  9.         System.out.println(Class.forName("S1"));   
  10.         System.out.println(Class.forName("S2"));   
  11.         System.out.println(Class.forName("S3"));   
  12.         System.out.println(Class.forName("S4"));   
  13.     }   
  14. }   
  15.   
  16. /*  
  17.     预先加载法  
  18.     优点:1.线程安全的,  
  19.           2.在类加载的同时已经创建好一个静态对象,调用时反应速度快。 
  20.  
  21.     缺点: 资源利用效率不高,可能这个单例不会需要使用也被系统加载 
  22.  */  
  23. class S1 {   
  24.     private S1() {   
  25.         System.out.println("ok1");   
  26.     }   
  27.   
  28.   
  29.     private static S1 instance = new S1();   
  30.   
  31.     public static S1 getInstance() {   
  32.         return instance;   
  33.     }   
  34. }   
  35.   
  36. /*  
  37.     initialization on demand,延迟加载法  (考虑多线程) 
  38.     优点:1.资源利用率高  
  39.     缺点:第一次加载是发应不快  ,多线程使用不必要的同步开销大 
  40.  
  41.  */  
  42. class S2 {   
  43.     private S2() {   
  44.         System.out.println("ok2");   
  45.     }   
  46.   
  47.     private static S2 instance = null;   
  48.   
  49.     public static synchronized S2 getInstance() {   
  50.         if (instance == null) instance = new S2();   
  51.         return instance;   
  52.     }   
  53. }   
  54.   
  55.   
  56. /*  
  57.     initialization on demand - double check 延迟加载法改进之双重检测  (考虑多线程) 
  58.     优点:1.资源利用率高  
  59.     缺点:第一次加载是发应不快  ,由于java 内存模型一些原因偶尔会失败 
  60.  
  61.  */  
  62. class S3 {   
  63.     private S3() {   
  64.         System.out.println("ok3");   
  65.     }   
  66.   
  67.     private static S3 instance = null;   
  68.   
  69.     public static S3 getInstance() {   
  70.         if (instance == null) {   
  71.             synchronized (S3.class) {   
  72.                 if (instance == null)   
  73.                     instance = new S3();   
  74.             }   
  75.         }   
  76.         return instance;   
  77.     }   
  78. }   
  79.   
  80.   
  81. /*  
  82.    initialization on demand holder  (考虑多线程) 
  83.    优点:1.资源利用率高  
  84.    缺点:第一次加载是发应不快  
  85.  
  86. */  
  87. class S4 {   
  88.     private S4() {   
  89.         System.out.println("ok4");   
  90.     }   
  91.   
  92.     private static class S4Holder {   
  93.         static S4 instance = new S4();   
  94.     }   
  95.   
  96.   
  97.     public static S4 getInstance() {   
  98.         return S4Holder.instance;   
  99.     }   
  100. }  


作为对象的创建模式[GOF95], 单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
  注:本文乃阎宏博士的《Java与模式》一书的第十五章。
  引言
  单例模式的要点

  单例单例
  显然单例模式的要点有三个;一是某各类只能有一个实例;二是它必须自行创建这个事例;三是它必须自行向整个系统提供这个实例。在下面的对象图中,有一个"单例对象",而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到,所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出,单例对象持有对自己的引用。

  资源管理
  一些资源管理器常常设计成单例模式。
  在计算机系统中,需要管理的资源包括软件外部资源,譬如每台计算机可以有若干个打印机,但只能有一个Printer Spooler, 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡,但是只应该有一个软件负责管理传真卡,以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。
  需要管理的资源包括软件内部资源,譬如,大多数的软件都有一个(甚至多个)属性(properties)文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。
  需要管理的软件内部资源也包括譬如负责记录网站来访人数的部件,记录软件系统内部事件、出错信息的部件,或是对系统的表现进行检查的部件等。这些部件都必须集中管理,不可政出多头。
  这些资源管理器构件必须只有一个实例,这是其一;它们必须自行初始化,这是其二;允许整个系统访问自己这是其三。因此,它们都满足单例模式的条件,是单例模式的应用。
  一个例子:Windows 回收站
  Windows 9x 以后的视窗系统中都有一个回收站,下图就显示了Windows 2000 的回收站。

  在整个视窗系统中,回收站只能有一个实例,整个系统都使用这个惟一的实例,而且回收站自行提供自己的实例。因此,回收站是单例模式的应用。
  双重检查成例
  在本章最后的附录里研究了双重检查成例。双重检查成例与单例模式并无直接的关系,但是由于很多C 语言设计师在单例模式里面使用双重检查成例,所以这一做法也被很多Java 设计师所模仿。因此,本书在附录里提醒读者,双重检查成例在Java 语言里并不能成立,详情请见本章的附录。
单例模式的结构
  单例模式有以下的特点:
   .. 单例类只可有一个实例。
   .. 单例类必须自己创建自己这惟一的实例。
   .. 单例类必须给所有其他对象提供这一实例。
  虽然单例模式中的单例类被限定只能有一个实例,但是单例模式和单例类可以很容易被推广到任意且有限多个实例的情况,这时候称它为多例模式(Multiton Pattern) 和多例类(Multiton Class),请见"专题:多例(Multiton )模式与多语言支持"一章。单例类的简略类图如下所示。
  由于Java 语言的特点,使得单例模式在Java 语言的实现上有自己的特点。这些特点主要表现在单例类如何将自己实例化上。
  饿汉式单例类饿汉式单例类是在Java 语言里实现得最为简便的单例类,下面所示的类图描述了一个饿汉式单例类的典型实现。
  从图中可以看出,此类已经自已将自己实例化。
  代码清单1:饿汉式单例类
public class EagerSingleton
{
private static final EagerSingleton m_instance =
new EagerSingleton();
/**
* 私有的默认构造子
*/
private EagerSingleton() { }
/**
* 静态工厂方法
*/
public static EagerSingleton getInstance()
{
·224·Java 与模式
return m_instance;
}
}
  读者可以看出,在这个类被加载时,静态变量m_instance 会被初始化,此时类的私有构造子会被调用。这时候,单例类的惟一实例就被创建出来了。
  Java 语言中单例类的一个最重要的特点是类的构造子是私有的,从而避免外界利用构造子直接创建出任意多的实例。值得指出的是,由于构造子是私有的,因此,此类不能被继承。
  懒汉式单例类
  与饿汉式单例类相同之处是,类的构造子是私有的。与饿汉式单例类不同的是,懒汉式单例类在第一次被引用时将自己实例化。如果加载器是静态的,那么在懒汉式单例类被加载时不会将自己实例化。如下图所示,类图中给出了一个典型的饿汉式单例类实现。

  代码清单2:懒汉式单例类
package com.javapatterns.singleton.demos;
public class LazySingleton
{
private static LazySingleton
m_instance = null;
/**
* 私有的默认构造子,保证外界无法直接实例化
*/
private LazySingleton() { }
/**
* 静态工厂方法,返还此类的惟一实例
*/
synchronized public static LazySingleton
getInstance()
{
if (m_instance == null)
{
m_instance = new LazySingleton();
}
return m_instance;
}
}
  读者可能会注意到,在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化,以处理多线程环境。有些设计师在这里建议使用所谓的"双重检查成例"。必须指出的是,"双重检查成例"不可以在Java 语言中使用。不十分熟悉的读者,可以看看后面给出的小节。
  同样,由于构造子是私有的,因此,此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的,在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲,这个比懒汉式单例类稍差些。
  从速度和反应时间角度来讲,则比懒汉式单例类稍好些。然而,懒汉式单例类在实例化时, 必须处理好在多个线程同时首次引用此类时的访问限制问题,特别是当单例类作为资源控制器,在实例化时必然涉及资源初始化,而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。
  饿汉式单例类可以在Java 语言内实现, 但不易在C++ 内实现,因为静态初始化在C++ 里没有固定的顺序,因而静态的m_instance 变量的初始化与类的加载顺序没有保证,可能会出问题。这就是为什么GoF 在提出单例类的概念时,举的例子是懒汉式的。他们的书影响之大,以致Java 语言中单例类的例子也大多是懒汉式的。实际上,本书认为饿汉式单例类更符合Java 语言本身的特点。
  登记式单例类
  登记式单例类是GoF 为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的。本书把他们的例子翻译为Java 语言,并将它自己实例化的方式从懒汉式改为饿汉式。只是它的子类实例化的方式只能是懒汉式的, 这是无法改变的。如下图所示是登记式单例类的一个例子,图中的关系线表明,此类已将自己实例化。

  代码清单3:登记式单例类
import java.util.HashMap;
public class RegSingleton
{
static private HashMap m_registry = new HashMap();
static
{
RegSingleton x = new RegSingleton();
m_registry.put( x.getClass().getName() , x);
}
/**
* 保护的默认构造子
*/
protected RegSingleton() {}
/**
* 静态工厂方法,返还此类惟一的实例
*/
static public RegSingleton getInstance(String name)
{
if (name == null)
{
name = "com.javapatterns.singleton.demos.RegSingleton";
}
if (m_registry.get(name) == null)
{
try
{
m_registry.put( name,
Class.forName(name).newInstance() ) ;
}
catch(Exception e)
{
System.out.println("Error happened.");
}
}
return (RegSingleton) (m_registry.get(name) );
}
/**
* 一个示意性的商业方法
*/
public String about()
{
return "Hello, I am RegSingleton.";
}
}
  它的子类RegSingletonChild 需要父类的帮助才能实例化。下图所示是登记式单例类子类的一个例子。图中的关系表明,此类是由父类将子类实例化的。

  下面是子类的源代码。
  代码清单4:登记式单例类的子类
import java.util.HashMap;
public class RegSingletonChild extends RegSingleton
{
public RegSingletonChild() {}
/**
* 静态工厂方法
*/
static public RegSingletonChild getInstance()
{
return (RegSingletonChild)
RegSingleton.getInstance(
"com.javapatterns.singleton.demos.RegSingletonChild" );
}
/**
* 一个示意性的商业方法
*/
public String about()
{
return "Hello, I am RegSingletonChild.";
}
}  
  在GoF 原始的例子中,并没有getInstance() 方法,这样得到子类必须调用的getInstance(String name)方法并传入子类的名字,因此很不方便。本章在登记式单例类子类的例子里,加入了getInstance() 方法,这样做的好处是RegSingletonChild 可以通过这个方法,返还自已的实例。而这样做的缺点是,由于数据类型不同,无法在RegSingleton 提供这样一个方法。由于子类必须允许父类以构造子调用产生实例,因此,它的构造子必须是公开的。这样一来,就等于允许了以这样方式产生实例而不在父类的登记中。这是登记式单例类的一个缺点。
  GoF 曾指出,由于父类的实例必须存在才可能有子类的实例,这在有些情况下是一个浪费。这是登记式单例类的另一个缺点。

GoF 曾指出,由于父类的实例必须存在才可能有子类的实例,这在有些情况下是一个浪费。这是登记式单例类的另一个缺点。
  在什么情况下使用单例模式

  使用单例模式的条件

  使用单例模式有一个很重要的必要条件:

  在一个系统要求一个类只有一个实例时才应当使用单例模式。反过来说,如果一个类可以有几个实例共存,那么就没有必要使用单例类。但是有经验的读者可能会看到很多不当地使用单例模式的例子,可见做到上面这一点并不容易,下面就是一些这样的情况。

  例子一

  问:我的一个系统需要一些"全程"变量。学习了单例模式后,我发现可以使用一个单例类盛放所有的"全程"变量。请问这样做对吗?

  答:这样做是违背单例模式的用意的。单例模式只应当在有真正的"单一实例"的需求时才可使用。

  一个设计得当的系统不应当有所谓的"全程"变量,这些变量应当放到它们所描述的实体所对应的类中去。将这些变量从它们所描述的实体类中抽出来, 放到一个不相干的单例类中去,会使得这些变量产生错误的依赖关系和耦合关系。

  例子二

  问:我的一个系统需要管理与数据库的连接。学习了单例模式后,我发现可以使用一个单例类包装一个Connection 对象,并在finalize()方法中关闭这个Connection 对象。这样的话,在这个单例类的实例没有被人引用时,这个finalize()对象就会被调用,因此,Connection 对象就会被释放。这多妙啊。

  答:这样做是不恰当的。除非有单一实例的需求,不然不要使用单例模式。在这里Connection 对象可以同时有几个实例共存,不需要是单一实例。

  单例模式有很多的错误使用案例都与此例子相似,它们都是试图使用单例模式管理共享资源的生命周期,这是不恰当的。

  单例类的状态

  有状态的单例类

  一个单例类可以是有状态的(stateful),一个有状态的单例对象一般也是可变(mutable) 单例对象。

  有状态的可变的单例对象常常当做状态库(repositary)使用。比如一个单例对象可以持有一个int 类型的属性,用来给一个系统提供一个数值惟一的序列号码,作为某个贩卖系统的账单号码。当然,一个单例类可以持有一个聚集,从而允许存储多个状态。

  没有状态的单例类

  另一方面,单例类也可以是没有状态的(stateless),仅用做提供工具性函数的对象。既然是为了提供工具性函数,也就没有必要创建多个实例,因此使用单例模式很合适。一个没有状态的单例类也就是不变(Immutable) 单例类; 关于不变模式,读者可以参见本书的"不变(Immutable )模式"一章。

  多个JVM 系统的分散式系统

  EJB 容器有能力将一个EJB 的实例跨过几个JVM 调用。由于单例对象不是EJB,因此,单例类局限于某一个JVM 中。换言之,如果EJB 在跨过JVM 后仍然需要引用同一个单例类的话,这个单例类就会在数个JVM 中被实例化,造成多个单例对象的实例出现。一个J2EE应用系统可能分布在数个JVM 中,这时候不一定需要EJB 就能造成多个单例类的实例出现在不同JVM 中的情况。

  如果这个单例类是没有状态的,那么就没有问题。因为没有状态的对象是没有区别的。但是如果这个单例类是有状态的,那么问题就来了。举例来说,如果一个单例对象可以持有一个int 类型的属性,用来给一个系统提供一个数值惟一的序列号码,作为某个贩卖系统的账单号码的话,用户会看到同一个号码出现好几次。

  在任何使用了EJB、RMI 和JINI 技术的分散式系统中,应当避免使用有状态的单例模式。

  多个类加载器

  同一个JVM 中会有多个类加载器,当两个类加载器同时加载同一个类时,会出现两个实例。在很多J2EE 服务器允许同一个服务器内有几个Servlet 引擎时,每一个引擎都有独立的类加载器,经有不同的类加载器加载的对象之间是绝缘的。

  比如一个J2EE 系统所在的J2EE 服务器中有两个Servlet 引擎:一个作为内网给公司的网站管理人员使用;另一个给公司的外部客户使用。两者共享同一个数据库,两个系统都需要调用同一个单例类。如果这个单例类是有状态的单例类的话,那么内网和外网用户看到的单例对象的状态就会不同。除非系统有协调机制,不然在这种情况下应当尽量避免使用有状态的单例类。

Revit+Deepseek AI插件保姆级安装教程:从零配置到一键生成模型 本文提供Revit集成Deepseek AI插件的完整安装与配置教程。从环境准备、插件获取安装,到Deepseek API密钥配置及界面集成,手把手指导用户实现从自然语言指令到三维模型的智能生成,旨在为建筑设计师带来革命性的高效工作流。 阅读详情

相关推荐

TwinCAT 3 实战:手把手教你用PLC和C++读写第三方伺服驱动器的CoE参数

本文详细介绍了在TwinCAT 3环境中通过PLC和C++两种技术路线实现对第三方伺服驱动器CoE参数的精准操控。从环境准备到具体实现,包括硬件配置、核心函数使用及性能优化策略,为工程师提供了全面的实战指南。特别针对CoE参数访问的效率和稳定性问题,给出了实用的调试技巧和异常处理方案。

weixin_33743248的博客 446

超详细:JAVA常用的设计模式汇总

上次我写的一篇博客《史上最最最简单的MVP教程》很多初学者看了都说简单易懂,我也觉得挺开心的,以后会写出更好的博客来帮助更多的人。 单例模式 简单点说,就是一个应用程序中,某个类的实例对象只有一个,你没有办法去new,因为构造器是被private修饰的,一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用,并不是一个新的实例,所以

AT弄潮儿 4492

Android GWP-Asan机制详解

基本用途:GWP-ASan是一种原生内存分配器功能,在内存分配时额外记录一些信息,用于检测DOUBLE_FREE、USE_AFTER_FREE、INVALID_FREE、BUFFER_OVERFLOW、BUFFER_UNDERFLOW五种内存错误问题。

专注于系统快稳省领域 4147

Java提高篇——单例模式

介绍    在我们日常的工作中经常需要在应用程序中保持一个唯一的实例,如:IO处理,数据库操作等,由于这些对象都要占用重要的系统资源,所以我们必须限制这些实例的创建或始终使用一个公用的实例,这就是我们今天要介绍的——单例模式(Singleton)。   单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最...

weixin_33958585的博客 178

FreeSWITCH彩铃与回铃音区别详解:从183/180信令到mod_da2检测模块

本文深入解析FreeSWITCH中彩铃与回铃音的技术差异,从183/180信令机制到mod_da2智能检测模块的实现原理。通过对比SIP协议中的早期媒体传输、回铃音补偿技术及实战案例,帮助开发者掌握VoIP系统中的关键音频处理技术,提升呼叫系统稳定性和用户体验。

tree8的博客 351

经典损失函数——均方误差(MSE)和交叉熵误差(CEE)的python实现

损失函数(loss function)用来表示当前的神经网络对训练数据不拟合的程度。这个损失函数有很多,但是一般使用均方误差和交叉熵误差等。 1.均方误差(mean squared error) 先来看一下表达式: 用于将的求导结果变成,是神经网络的输出,是训练数据的标签值,k表示数据的维度。 用python实现: def MS...

Answer3664的博客 1万+

微信小程序OCR身份证识别实战:从拍照到信息提取全流程解析

本文详细解析了微信小程序中OCR身份证识别的全流程实现,从环境配置、拍照上传到OCR核心识别及安全优化。通过微信开发者工具和OCR插件,开发者可快速构建高效的身份信息采集系统,提升用户体验和数据安全性。重点介绍了图像处理、加密传输及混合云架构等企业级解决方案。

j0k1l2m3n的博客 458

Java-单例设计模式

所谓单例设计模式,简单来说,就是在整个应用中保证只有一个类的实例存在。相当于Java Web中的application,也就是提供了一个全局变量,用处相当广泛,比如保存全局数据,实现全局性的操作等。保证了一个类在内存中的对象唯一性。

午安的博客 413

YOLOv11改进 | 细节涨点篇 | DySample一种最新的轻量化动态上采样算子(效果完爆CARAFE)

本文给大家带来的最新改进机制是一种号称超轻量级且有效的动态上采样器——DySample。与传统的基于内核的动态上采样器相比,DySample采用了一种基于点采样的方法,相比于以前的基于内核的动态上采样器,DySample具有更少的参数、浮点运算次数、GPU内存和延迟。此外,DySample在包括语义分割、目标检测、实例分割、全景分割和单目深度估计在内的五个预测任务中,性能均优于其他上采样器(截至目前最有效的上采样算子),

Snu77的博客 4213

针对小缺陷目标:在YOLOv11中引入小目标检测层

摘要: 针对YOLOv11在工业检测中漏检微小目标(如焊点气泡)的问题,研究发现深层特征下采样导致小目标信息丢失。通过在YOLOv11中增加P2检测层(4倍下采样)并融合浅层高分辨率特征,可显著提升小目标召回率。关键优化包括:调整模型结构、谨慎设计数据增强策略(减少MixUp、增加小目标粘贴)、重新分配损失权重(提升P2层权重)、优化推理速度(动态分辨率、通道裁剪)。同时强调数据质量的重要性,建议根据具体场景特性(目标尺寸、分布)定制方案,而非盲目调整模型。

as1225120794的博客 366

Java单例模式探讨

单例模式网上有很多种写法,目前个人认为相对比较好的写法是本篇的最后一个

骑猪追大象 664

诊断数据库ODX标准协议ISO22901定义组成部分

综上所述,简略描述了ODX数据库中UML/XML/Text/Check rules具体功能以及详细内容。

Soly_kun的博客 907
上一篇: 算法:排序----Java快速排序
下一篇: static class 静态类(Java)
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值