（1）饿汉模式
package singleton;
/**
* 饿汉模式 多线程环境下实现单例模式
* @author zc
*
*/
public class SingletonE {
//立即加载 饿汉模式
private static SingletonE singleton=new SingletonE();
//私有化构造方法
private SingletonE() {
}
public static SingletonE getInstance() {
return singleton;
}
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
class MyThread extends Thread{
@Override
public void run() {
System.out.println(SingletonE.getInstance().hashCode());
}
}
（2）懒汉模式
package singleton;
/**
* 双加锁机制 实现懒汉模式的多线程环境下的单例模式
* @author zc
*
*/
public class SingletonL {
private volatile static SingletonL singleton ;
private SingletonL() {
}
public static SingletonL getInstance() throws InterruptedException {
if(singleton==null) {
//模拟实例化之前的准备工作
Thread.sleep(2000);
synchronized(SingletonL.class) {
if(singleton==null) {
singleton =new SingletonL();
}
}
}
return singleton;
}
public static void main(String[] args) {
MyThread2 t1 = new MyThread2();
MyThread2 t2 = new MyThread2();
MyThread2 t3 = new MyThread2();
t1.start();
t2.start();
t3.start();
}
}
class MyThread2 extends Thread{
@Override
public void run() {
try {
System.out.println(SingletonL.getInstance().hashCode());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
（3）静态内置类
package singleton;
/**
* 静态内置类实现多线程环境下的单利模式
* @author zc
*
*/
public class SingletonInner {
private static class SingletonInnerHandler{
private static SingletonInner singleton = new SingletonInner();
}
//私有化构造方法
private SingletonInner() {
}
public static SingletonInner getInstance(){
return SingletonInnerHandler.singleton;
}
public static void main(String[] args) {
MyThread3 t1= new MyThread3();
MyThread3 t2= new MyThread3();
MyThread3 t3= new MyThread3();
t1.start();
t2.start();
t3.start();
}
}
class MyThread3 extends Thread{
@Override
public void run() {
System.out.println(SingletonInner.getInstance().hashCode());
}
}
（4）序列化和反序列化
package singleton;
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;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
* 多线程环境下序列化和反序列化的单例模式
* @author zc
*
*/
public class SingletonSerializable implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
//内部类的方式
private static class SingletonSerializableHandler{
private static final SingletonSerializable singelton = new SingletonSerializable();
}
//私有化构造函数
private SingletonSerializable() {
}
public static SingletonSerializable getInstance() {
return SingletonSerializableHandler.singelton;
}
//序列化需要重写这个方法
protected Object readResolve() throws ObjectStreamException{
System.out.println("调用了readResolve方法");
return SingletonSerializableHandler.singelton;
}
public static void main(String[] args) {
SingletonSerializable myObject =SingletonSerializable.getInstance();
//向文件写入对象，序列化对象
try {
FileOutputStream fout = new FileOutputStream(new File("myobject.tx"));
ObjectOutputStream oout= new ObjectOutputStream(fout);
oout.writeObject(myObject);
oout.close();
fout.close();
System.out.println(myObject.hashCode());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//读出对象，反序列化对象
try {
FileInputStream finput = new FileInputStream(new File("myobject.tx"));
ObjectInputStream oinput= new ObjectInputStream(finput);
SingletonSerializable myObject2 = (SingletonSerializable) oinput.readObject();
oinput.close();
finput.close();
System.out.println(myObject2.hashCode());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
（5） enum枚举
package singleton;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
* 使用enum枚举实现多线程环境下的单例模式
* @author zc
*
*/
public class SingletonEnum {
public enum MyEnumSingleton{
connectionFactory;
//mysql连接
private Connection connection;
//构造函数
private MyEnumSingleton() {
try {
System.out.println("创建MyObject对象");
String url="jdbc:mysql://localhost:3306/sakila?useUnicode=true&characterEncoding=UTF-8";
String username="root";
String password="root";
String driverName="com.mysql.jdbc.Driver";
Class.forName(driverName);
connection =DriverManager.getConnection(url,username,password);
} catch (ClassNotFoundException | SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Connection getConnection() {
return connection;
}
}
//外层封装连接
public static Connection getConnection() {
return MyEnumSingleton.connectionFactory.getConnection();
}
public static void main(String[] args) {
MyThread4 t1 = new MyThread4();
MyThread4 t2 = new MyThread4();
MyThread4 t3 = new MyThread4();
t1.start();
t2.start();
t3.start();
}
}
class MyThread4 extends Thread{
@Override
public void run() {
System.out.println(SingletonEnum.getConnection().hashCode());
}
}
