java单例模式和线程安全问题怎么解决

这篇文章主要介绍“java单例模式和线程安全问题怎么解决”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“java单例模式和线程安全问题怎么解决”文章能帮助大家解决问题。

单例模式、多实例模式、和线程安全

单例模式

单例模式是指确保一个类仅有一个唯一的实例，并且提供了一个全局的访问点。

分类： 懒汉式、饿汉式

为什么需要单例模式？

再某些特殊的情况下，存在一个类仅能用来产生一个唯一对象的必要性。例如：打印机室有许多打印机，但是它的打印管理系统只有一个打印任务控制对象，该对象管理打印排队并分配打印任务给各个打印机。单例模式正是为了解决这样的需求而产生的。

实现思路：

为了防止客户端利用构造器创建多个对象，将构造方法声明为 private 类型。但这样会使得这个类不可用，所以必须提供一个可以获得实例的静态方法，通常称为 getInstance 方法， 该方法返回一个实例。这个方法必须是静态的，因为静态方法是根据类名调用的，否则也是无法使用的。

类图：懒汉式

类图：饿汉式

先来看一个简单的例子：

测试单例类：Dog’

//懒汉式
public class Dog {
    private static Dog dog;
    private String name;
    private int age;

    //私有的构造器
    private Dog() {}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //静态工厂方法
    public static Dog getInstance() {
        if (dog == null) {
            dog = new Dog();
        }
        return dog;
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
}

测试单例类：Cat

//饿汉式
public class Cat {
    private static Cat cat = new Cat();
    private String name;
    private int age;

    //私有构造器
    private Cat() {}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //静态工厂方法
    public static Cat getInstance() {
        return cat;
    }

    @Override
    public String toString() {
        return "Cat [name=" + name + ", age=" + age + "]";
    }
}

测试类

import java.util.HashSet;
import java.util.Set;

public class Client {

    public static void main(String[] args) {
        //单线程模式测试
        Dog dog1 = Dog.getInstance();
        Dog dog2 = Dog.getInstance();
        System.out.println("dog1 == dog2: "+(dog1 == dog2));

        Cat cat1 = Cat.getInstance();
        Cat cat2 = Cat.getInstance();
        System.out.println("cat1 == cat2: "+(cat1 == cat2));
    }
}

运行结果

懒汉式和饿汉式对比

创建区别

懒汉式是在第一次调用静态方法 getInstance() 时创建单例对象。
饿汉式是在类加载时创建单例对象，即在声明静态单例对象时实例化单例类。

线程安全

懒汉式是线程不安全的，而饿汉式是线程安全的（下面会测试）。

资源占用

懒汉式是等到使用时才会创建，而饿汉式是在类加载时创建。所以懒汉式没有饿汉式快，但是饿汉式比较占用资源，如果一直不使用，会很占据资源。

多线程模式下的安全性

多线程类

import java.util.HashSet;
import java.util.Set;

public class DogThread extends Thread{
    private Dog dog;
    private Set<Dog> set;

    public DogThread() {
        set = new HashSet<>();
    }

    //这个方法是为了测试添加的。
    public int getCount() {
        return set.size();
    }

    @Override
    public void run() {
        dog = Dog.getInstance();
        set.add(dog);
    }
}

多线程测试类

import java.util.HashSet;
import java.util.Set;

public class Client {

    public static void main(String[] args) {
        //单线程模式测试
        Dog dog1 = Dog.getInstance();
        Dog dog2 = Dog.getInstance();
        System.out.println("dog1 == dog2: "+(dog1 == dog2));

        Cat cat1 = Cat.getInstance();
        Cat cat2 = Cat.getInstance();
        System.out.println("cat1 == cat2: "+(cat1 == cat2));

        //多线程模式测试
        DogThread dogThread = new DogThread();
        Thread thread = null;
        for (int i = 0; i < 10; i++) {
            thread = new Thread(dogThread);
            thread.start(); 
        }

        try {
            Thread.sleep(2000); //主线程等待子线程完成！
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("dog's number: "+dogThread.getCount());
    }
}

运行结果
注意：多线程的结果是很难预测的，这里涉及线程的竞争，可能多次运行结果是一样的（多次一样并不代表是绝对正确），但是只要多次测试，就能看到不一样的结果。

说明

这里我使用一点集合的技巧，利用 Set 集合的特性，把每次产生的 dog 对象存入 Set集合中，最后只要调用集合的 size() 方法就行了。可以看出来产生了两个 dog 对象，这就是产生了错误，这就是属于编程错误了。还要明白多线程下不一定会出错，所以产生的 dog 对象小于线程数。
由于 饿汉式单例 是线程安全的，这里就不测试了，有兴趣的可以测试一下。

解决懒汉式单例线程安全的方法：同步
注意：同步有很多种方法，也可以使用 Lock 进行处理，同步是一种方法，不是特指 synchronzied 这个关键字，感兴趣的人可以多探究一下。
并且同步的方法通常比较慢，性能方面也要权衡。

  //静态同步工厂方法
    public synchronized static Dog getInstance() {
        if (dog == null) {
            dog = new Dog();
        }
        return dog;
    }

多实例模式

这里补充一个多实例的模式，就是对象数量是固定数目的。可以看出单例模式的推广。当然了实现方式也有很多，大家可以尝试以下，这里是我的方式。

多实例模式类

//固定数目实例模式
public class MultiInstance {
    //实例数量,这里为四个
    private final static int INSTANCE_COUNT = 4;
    private static int COUNT = 0;
    private static MultiInstance[] instance = new MultiInstance[4];

    private MultiInstance() {};

    public static MultiInstance getInstance() {
        //注意数组的下标只能为 COUNT - 1
        if (MultiInstance.COUNT <= MultiInstance.INSTANCE_COUNT - 1) {
            instance[MultiInstance.COUNT] = new MultiInstance();
            MultiInstance.COUNT++;
        }
        //返回实例前，执行了 COUNT++ 操作，所以 应该返回上一个实例
        return MultiInstance.instance[MultiInstance.COUNT-1];  
    }
}

测试类

import java.util.HashSet;
import java.util.Set;

public class Test {
    public static void main(String[] args) {

        System.out.println("------------------------");
        testMultiInstance();
    }

    //测试多实例模式（单例的扩展，固定数目实例）
    public static void testMultiInstance() {
        Set<MultiInstance> instanceSet = new HashSet<>();
        MultiInstance instance = null;
        for (int i = 0; i < 10; i++) {
            instance = MultiInstance.getInstance();
            instanceSet.add(instance);
        }
        System.out.println("8个实例中，不同的实例有："+instanceSet.size());   
    }
}

运行结果
注意：如果在多线程环境下使用，也是要考虑线程安全的。感兴趣的可以自己实现一下。

单例模式一定是安全的吗？

不一定，有很多方法可以破坏单例模式！

这里举例看一看（我只能举我知道的哈！其他的感兴趣，可以去探究一下！）
使用反射：这种办法是非常有用的，通过反射即使是私有的属性和方法也可以访问了，因此反射破坏了类的封装性，所以使用反射还是要多多小心。但是反射也有许多其他的用途，这是一项非常有趣的技术（我也只是会一点点）。

使用反射破坏单例模式测试类

这里使用的还是前面的 Dog 实体类。注意我这里的**包名：**com。
所有的类都是在 com包 下面的。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Client {
    public static void main(String[] args) throws 
    ClassNotFoundException, 
    NoSuchMethodException, 
    SecurityException, 
    InstantiationException, 
    IllegalAccessException, 
    IllegalArgumentException, 
    InvocationTargetException {

        Class<?> clazz = Class.forName("com.Dog");
        Constructor<?> con = clazz.getDeclaredConstructor();
        //设置可访问权限
        con.setAccessible(true);
        Dog dog1 = (Dog) con.newInstance();
        Dog dog2 = (Dog) con.newInstance();
        System.out.println(dog1 == dog2);
    }
}

说明：反射的功能是很强大的，从这里既可以看出来，正是有了反射，才使得Java 语言具有了更多的特色，这也是Java的强大之处。

使用对象序列化破坏单例模式

测试实体类：Dog（增加一个对象序列化接口实现）

import java.io.Serializable;
//懒汉式
public class Dog implements Serializable{
    private static final long serialVersionUID = 1L;

    private static Dog dog;
    private String name;
    private int age;

    //私有的构造器
    private Dog() {}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //静态工厂方法
    public synchronized static Dog getInstance() {
        if (dog == null) {
            dog = new Dog();
        }
        return dog;
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
}

对象序列化测试类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Dog dog1 = Dog.getInstance();
        dog1.setName("小黑");
        dog1.setAge(2);
        System.out.println(dog1.toString());

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(dog1);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Dog dog2 = (Dog) ois.readObject();
        System.out.println(dog2.toString());
        System.out.println("dog1 == dog2: "+(dog1 == dog2));

    }
}

运行结果

说明
这里可以看出来通过对象序列化（这里也可以说是对象的深拷贝或深克隆），
同样也可以实现类的实例的不唯一性。这同样也算是破坏了类的封装性。对象序列化和反序列化的过程中，对象的唯一性变了。

这里具体的原因很复杂，我最近看了点深拷贝的知识，所以只是知其然不知其之所以然。(所以学习是需要不断进行的！加油诸位。)
这里我贴一下别的经验吧：（感兴趣的可以实现一下！）

为什么序列化可以破坏单例了？
答：序列化会通过反射调用无参数的构造方法创建一个新的对象。

这个东西目前超出了我的能力范围了，但也是去查看源码得出来的，就是序列化(serializable)和反序列化(externalizable)接口的详细情况了。但是有一点，它也是通过反射来做的的，所以可以看出**反射（reflect）**是一种非常强大和危险的技术了。