java单例模式(java单例模式线程安全)

ゞ浴缸里的玫瑰 2023-09-25 08:36 31阅读 0赞

## 　Java中单例模式是什么？ ##

name=name;

//1，该类只能有一个实例

private TestStream()\{\} //私有无参构造方法

//2，该类必须自行创建

//2种方式

//private static final TestStream ts=new TestStream();

private static TestStream ts1=null;

//3而且这个类必须自动向整个系统提供这个实例

public synchronized static TestStream getTest()

if(ts1==null)

ts1=new TestStream();

return ts1;

public void getInfo()

System。

![java单例模式][java]

## Java中单例模式有哪些实现方法？Java中单例模式有哪些实现方 ##

实现在tomcat中跑多个服务器实例

初学Java多线程:使用Runnable接口创建线程

第一种：同步

public class Singleton \{

private static Singleton instance;

private Singleton() \{

public synchronized static Singleton getInstance() \{

if (instance == null) \{

instance = new Singleton();

return instance;

第二种：静态初始化

public class Singleton \{

private static Singleton instance = new Singleton();

private Singleton() \{

public static Singleton getInstance() \{

return instance;

第三种：静态holder类

public class Singleton \{

private Singleton() \{

private static class SingletonHolder \{

public static Singleton instance = new Singleton();

public static Singleton getInstance() \{

return SingletonHolder。

## JAVA单例模式的几种实现方法 ##

单例模式的几种实现方法

1.饿汉式单例类

package

pattern.singleton;

饿汉式单例类

在类初始化时，已经自行实例化

public

class

Singleton1

私有的默认构造子

private

Singleton1()

已经自行实例化

private

static

final

Singleton1

single

Singleton1();

静态工厂方法

public

static

Singleton1

getInstance()

return

single;

懒汉式单例类

package

pattern.singleton;

懒汉式单例类

在第一次调用的时候实例化

public

class

Singleton2

私有的默认构造子

private

Singleton2()

注意，这里没有

final

private

static

Singleton2

single;

只实例化一次

static

single

Singleton2();

静态工厂方法

public

synchronized

static

Singleton2

getInstance()

(single

single

Singleton2();

return

single;

在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。有些设计师在这里建议使用所谓的

双重检查成例

必须指出的是，

双重检查成例

语言中使用。不十分熟悉的读者，可以看看后面给出的小节。

样，由于构造子是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉

式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，

比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处

理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源

初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

饿汉式单例类可以在

语言内实现，

内实现，因为静态初始化在

里没有固定的顺序，因而静态的

m\_instance

变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么

在提出单例类的概念时，举的例子是懒

汉式的。他们的书影响之大，以致

语言中单例类的例子也大多是懒汉式的。实际上，本书认为饿汉式单例类更符e69da5e887aae799bee5baa631333335336530合

言本身的特点。

登记式单例类

package

pattern.singleton;

import

java.util.HashMap;

import

java.util.Map;

登记式单例类

Spring

里面的方法，将类名注册，下次从里面直接获取。

public

class

Singleton3

private

static

Map

HashMap ();

static

Singleton3

single

Singleton3();

map.put(single.getClass().getName(),

single);

保护的默认构造子

protected

Singleton3()\{\}

静态工厂方法

返还此类惟一的实例

public

static

Singleton3

getInstance(String

name)

(name

Singleton3.

class

.getName();

System.out.println("name

null"+"--->name="+name);

(map.get(name)

map.put(name,

(Singleton3)

Class.forName(name).newInstance());

catch

(InstantiationException

e.printStackTrace();

catch

(IllegalAccessException

e.printStackTrace();

catch

(ClassNotFoundException

e.printStackTrace();

return

map.get(name);

一个示意性的商业方法

public

String

about()

return

"Hello,

RegSingleton.";

public

static

main(String\[\]

args)

Singleton3

single3

Singleton3.getInstance(

System.out.println(single3.about());

\}三种，懒汉，饿汗，饥渴汗单例模式1：

public class singleton\{

private static singleton st = null;

private singleton()\{ \}

public static singleton getinstance()\{

if(st == null)\{

st = new singleton();

return st;

单例模式2：

public class singleton\{

private static singleton st = new singleton();

private singleton()\{ \}

public static singleton getinstance()\{

return st;

多线程1：

导入thread所在的包

public class mythread1 extends thread\{

public void run()\{

xxxxx写自己的代码

导入runnable所在的包

public class mythread2 implements runnable\{

public void run()\{

xxxxx写自己的代码

另写一个测试类，在main方法中这样写：

thread t = new mythread1();

runnable r = new mythread2();

thread t = new thread(r);2 种

![java单例模式][java 1]

## java 单例模式 介绍 ##

一是某个类只能有一个实例；

二是它必须自行创建这个实例；

三是它必须自行向整个系统提供这个实例

public class Singleton \{ //在自己内部定义自己的一个实例，只供内部调用

private static Singleton instance = new Singleton();

private Singleton()\{ //do something

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance()\{

return instance;

简单的理解：

1.必须有一个私有的静态对象指向自己

2.私有的构造方法，防止new对象

3.提供一个方法，供外部获取本身对象私有构造,都引用一个实例;独占访问

if(a==null)\{

a=new A();

return a,只能有一个实例

Class A()\{

private static A a=null,例如;

private A()\{\}///,不能在外部构造了

public synchronized static A getInstance()\{/只创建一个实例ava模式设计之单例模式的比较详细的资料可以百度搜：Java模式设计之单例模式 第一个豆豆网ddvip就是哦～单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

特点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

你的理解是正确的只能有一实例

[java]: https://img1.baidu.com/it/u=295787962,3318085259&fm=26&fmt=auto
[java 1]: https://img1.baidu.com/it/u=1826079001,3466970796&fm=26&fmt=auto