java - 不同(不相同)的副本集是从单例对象返回的

Question

请参阅以下流程以了解确切的问题:

1. Tomcat 启动——第一次实例化单例对象。一些初始数据是从数据库设置在该对象中的。例如数据是 {XXXX, YYYY}

2. 每次请求都会返回现有的相同副本{XXXX, YYYY}。

3. 数据库中的数据值发生更改，并且在数据库数据更改后从不同线程创建一个标志文件。例如数据已更新{XXXX, YYYY, ZZZZ}

4. 单例对象请求期间文件存在检查。如果文件存在重新实例化的单例对象并具有新值。

5. 单例对象被刷新。 {XXXX, YYYY, ZZZZ}

6. 在#5之后，有些请求获取了单例对象的新副本{XXXX, YYYY, ZZZZ}，但是有些请求获取了单例对象的旧副本{XXXX, YYYY}。

造成这种差异的可能原因是什么？

源代码

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedHashMap;

import org.w3c.dom.css.Counter;


public class SingeltonObject {
      private NodesHashMap allNodes;
    private static SingeltonObject _instance = null;
    public static int counter=0;
private SingeltonObject() throws Exception{
    refresh();

}

static public SingeltonObject getInstance() throws Exception{
    if(_instance==null){
        System.out.println(" ::: First Time invoked ::: ");
        _instance = new SingeltonObject();

    }else{
        System.out.println("Thread :: "+Thread.currentThread().getName());
        System.out.println("Time :: "+System.currentTimeMillis());
        File flagFile = new File("C:/Users/rahul.singh/Desktop/Test/test.txt");
        if(flagFile.exists()){
            System.out.println("In IF"+Thread.currentThread().getName());
            _instance = new SingeltonObject();
            if(flagFile.delete()){
                System.out.println("In Delete :: "+Thread.currentThread().getName());
                System.out.println("File deleted Succesfully");
            }
            else{
                System.out.println("Not deleted");
            }
        }
    }


    return _instance;
}
public void refresh() throws Exception{

    allNodes = getAllNodes();

}
public static ArrayList<String> getAllNodesIDList() throws Exception {
    ArrayList<String> nodeidlist = new ArrayList<String>();
    for (String node : getInstance().allNodes.keySet()) {
        nodeidlist.add(node);
    }
    nodeidlist.trimToSize();
    return nodeidlist;
}

public static NodesHashMap getAllNodes() throws Exception {


        NodesHashMap nodesinfo = new NodesHashMap();
        ArrayList<String> nodeinfo1 = new ArrayList<String>();
        nodeinfo1.add("XN0101 MIX XN4");
        ArrayList<String> nodeinfo2 = new ArrayList<String>();
        nodeinfo2.add("XN0102 MIX XN4");
        ArrayList<String> nodeinfo3 = new ArrayList<String>();
        nodeinfo3.add("XN0103 MIX XN4");

        nodesinfo.put("XN0101", nodeinfo1);
        nodesinfo.put("XN0102", nodeinfo2);
        nodesinfo.put("XN0103", nodeinfo3);
        if(Thread.currentThread().getName().equals("T5")){
            ArrayList<String> nodeinfo4 = new ArrayList<String>();
            nodeinfo3.add("XN0104 MIX XN4");
            nodesinfo.put("XN0104", nodeinfo3);
        }

    return nodesinfo;


}

 private static class NodesHashMap extends
LinkedHashMap<String, ArrayList<String>> {
public ArrayList<String> get(String obj) throws Exception {
ArrayList<String> ret = super.get(obj);
if (ret == null) {
    SingeltonObject.getInstance().refresh();
    ret = SingeltonObject.getInstance().allNodes.get(obj);
}
return ret;
}
};
}



import java.io.File;


public class ThreadClient extends Thread{
    Thread thread1 = new Thread("T1") {

        @Override
        public void run() {
            try {
                System.out.println("T1 RUN");
                SingeltonObject.getInstance();
                SingeltonObject.getAllNodesIDList();
                System.out.println(SingeltonObject.getAllNodesIDList());

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    };
    Thread thread2 = new Thread("T2") {

        @Override
        public void run() {
            try {
                System.out.println("T2 RUN");
                SingeltonObject.getInstance();
                SingeltonObject.getAllNodesIDList();
                System.out.println(SingeltonObject.getAllNodesIDList());

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    };
    Thread thread3 = new Thread("T3") {

        @Override
        public void run() {
            try {
                System.out.println("T3 RUN");
                SingeltonObject.getInstance();
                SingeltonObject.getAllNodesIDList();
                System.out.println(SingeltonObject.getAllNodesIDList());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    };
    Thread thread4 = new Thread("T4") {

        @Override
        public void run() {
            try {
                System.out.println("T4 RUN");
                SingeltonObject.getInstance();
                SingeltonObject.getAllNodesIDList();
                System.out.println(SingeltonObject.getAllNodesIDList());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    };
Thread thread5 = new Thread("T5") {

        @Override
        public void run() {
            try {
                System.out.println("T5 RUN");
                SingeltonObject.getInstance().refresh();
                SingeltonObject.getAllNodesIDList();
                System.out.println(SingeltonObject.getAllNodesIDList());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    };

    public static void main(String[] args) throws Exception {
        SingeltonObject.getInstance();
        ThreadClient tclient = new ThreadClient();
        File file = new File("C:/Users/rahul.singh/Desktop/Test/test.txt");
        file.createNewFile();
        tclient.run();


    }
    public void run(){
        try {
            thread1.start();
            thread1.join();
            thread2.start();
            thread2.join();
            thread5.start();
            thread5.join();
            thread3.start();
            thread3.join();

            thread4.start();
            thread4.join();
            System.out.println("main thread finished");
        } catch (Exception e) {
            // TODO: handle exception
        }


    }
}

又报告了一个与单例对象未刷新相关的问题。

1. Tomcat 启动——第一次实例化单例对象。一些初始数据是从数据库设置在该对象中的。例如数据为{XXXX, YYYY}

2. 每次请求都会返回现有的相同副本{XXXX, YYYY}。

3. 数据库中的数据值发生更改，并且在数据库数据更改后从不同线程创建一个标志文件。例如数据已更新{XXXX, YYYY, ZZZZ}

4. 单例对象请求期间文件存在检查。如果文件存在单例对象，则重新实例化并具有新值。

5. 单例对象未刷新。 {XXXX, YYYY}

6. 在#5之后，所有请求都获取了单例对象的旧副本{XXXX, YYYY}

Answer 1

如果您使用枚举，它将更简单且线程安全

public enum SingletonObject {
    INSTANCE;

    SingletonObject() {
        System.out.println("Thread :: " + Thread.currentThread().getName());
        System.out.println("Time :: " + System.currentTimeMillis());
        File flagFile = new File("C:/Users/rahul.singh/Desktop/Test/test.txt");
        if (flagFile.exists()) {
            System.out.println("In IF" + Thread.currentThread().getName());
            if (flagFile.delete()) {
                System.out.println("In Delete :: " + Thread.currentThread().getName());
                System.out.println("File deleted Succesfully");
            } else {
                System.out.println("Not deleted");
            }
        }
    }
}