Java 如何将哈希映射发送到run方法？

我正在编写java客户端和服务器，希望在其中维护多个线程之间的哈希映射。我已经编写了以下代码，但无法在run方法中访问更新的代码。在这种情况下，并发哈希映射是否更有用？任何提示都会非常有用。提前谢谢

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import org.json.simple.JSONObject;


public class JavaServer extends Thread{

    //To access packet in run method
    static byte[] receiveData=new byte[2048];
    DatagramPacket receivePacket = new DatagramPacket(receiveData,
            receiveData.length);
    JavaGenericCryptoLibrary cryptoObj=new JavaGenericCryptoLibrary();
    static JavaBuisinessFunctionsServer objB=new JavaBuisinessFunctionsServer();
    static DatagramSocket ds;
    static Map<String,String>  hm = new HashMap<String,String>();
    public JavaServer(DatagramSocket ds, Map<String,String> hm1) {
        JavaServer.ds=ds;
        JavaServer.hm=hm1;
    }


    public static void main(String[] args)
    {
        @SuppressWarnings("unused")
        JSONObject receivedObj = null;
        try {
            // Port Number for login
            int serverPort_login = 3964;
            int serverPort_requests = 3764;

            DatagramSocket serverSocket = new DatagramSocket(serverPort_login);
            DatagramSocket serverSocket_clients = new DatagramSocket(serverPort_requests);
            DatagramPacket receivePacket = new DatagramPacket(receiveData,
                    receiveData.length);

            hm.put("Current_User","Blank");
            // Server initialized
            System.out.println("Intilized Server");
            while(true)
            {   
                hm.remove("Current_User");
                hm.put("Current_User","Blank");
                serverSocket.receive(receivePacket);
                hm=(HashMap<String, String>) objB.login(serverSocket,receivePacket.getAddress(),receivePacket.getPort(),(HashMap<String, String>) hm);
                System.out.println("current user at server"+hm.get("Current_User"));
                //JavaServer r = new JavaServer(serverSocket_clients,hm);
                System.out.println("before thread:"+JavaServer.hm.get("Current_User"));
                System.out.println("before thread:"+JavaServer.hm.get(JavaServer.hm.get("Current_User")));

                new JavaServer(serverSocket_clients, hm).start();
            }
        } catch (Exception e) {
            System.out.println("Server" + e);
        } 
    }

    @SuppressWarnings("unchecked")
    public void run()
    {
        try {
            // Packet received on the thread.
            // Respective function will be initialized 
            JSONObject online_user_json_obj=new JSONObject();
            while(true)
            {   
                ds.receive(receivePacket);
                JSONObject t=cryptoObj.readRecievedPacket(receivePacket);
                switch((String)t.get("Command"))
                {
                case "Chat":

                    break;
                case "Logout":

                    break;
                case "List":

                    Enumeration<String> online_users = cryptoObj.get_Online_Users();
                    online_user_json_obj.put("List", online_users);
                    String user=hm.get("Current_User");
                    System.out.println("user "+user);
                    String ip_port=hm.get(user);
                    System.out.println("ip_port"+ip_port);
                                    //Here I amnot getting updated values
                    String[] ip_port_arr=ip_port.split(" ");
                    System.out.println(ip_port_arr[0]);
                    InetAddress ia=InetAddress.getByName(ip_port_arr[0]);
                    int port=Integer.getInteger(ip_port_arr[1]);
                    ds.send(cryptoObj.udpPacketGenerator(online_user_json_obj,ia,port));
                    break;
                default:
                    System.out.println("Rogue Data");
                    break;
                }

            } 
        }catch (Exception e) {
            e.printStackTrace();
        }   

    }
}

导入java.net.DatagramPacket；
导入java.net.DatagramSocket；
导入java.net.InetAddress；
导入java.util.Enumeration；
导入java.util.HashMap；
导入java.util.Map；
导入org.json.simple.JSONObject；
公共类JavaServer扩展线程{
//在run方法中访问数据包
静态字节[]接收数据=新字节[2048]；
DatagramPacket ReceivePackage=新的DatagramPacket（receiveData，
接收数据。长度）；
JavaGenericCryptoLibrary Cryptobj=新的JavaGenericCryptoLibrary（）；
静态JavabusinessFunctionsServer objB=新JavabusinessFunctionsServer（）；
静态数据采集器ds；
静态映射hm=新的HashMap（）；
公共JavaServer（DatagramSocket ds，映射hm1）{
JavaServer.ds=ds；
JavaServer.hm=hm1；
}
公共静态void main（字符串[]args）
{
@抑制警告（“未使用”）
JSONObject receivedObj=null；
试一试{
//用于登录的端口号
int serverPort_login=3964；
int serverPort_请求=3764；
DatagramSocket serverSocket=新的DatagramSocket（serverPort\u登录）；
DatagramSocket serverSocket_客户端=新DatagramSocket（serverPort_请求）；
DatagramPacket ReceivePackage=新的DatagramPacket（receiveData，
接收数据。长度）；
hm.put（“当前用户”、“空白”）；
//服务器已初始化
System.out.println（“初始化服务器”）；
while（true）
{   
hm.remove（“当前用户”）；
hm.put（“当前用户”、“空白”）；
serverSocket.receive（接收数据包）；
hm=（HashMap）objB.login（serverSocket，receivePacket.getAddress（），receivePacket.getPort（），（HashMap）hm）；
System.out.println（“服务器上的当前用户”+hm.get（“当前用户”）；
//JavaServer r=新的JavaServer（serverSocket\u客户机，hm）；
System.out.println（“在线程之前：+JavaServer.hm.get（“当前用户”）；
System.out.println（“线程之前：+JavaServer.hm.get（JavaServer.hm.get（“当前用户”）））；
新的JavaServer（serverSocket_客户端，hm）.start（）；
}
}捕获（例外e）{
System.out.println（“服务器”+e）；
} 
}
@抑制警告（“未选中”）
公开募捐
{
试一试{
//线程上接收到的数据包。
//相应的功能将被初始化
JSONObject online_user_json_obj=新建JSONObject（）；
while（true）
{   
ds.接收（接收数据包）；
JSONObject t=Cryptobj.ReadReceivedPacket（receivePacket）；
开关（（字符串）t.get（“命令”））
{
案例“聊天”：
打破
案例“注销”：
打破
案例“列表”：
枚举在线用户=加密对象。获取在线用户（）；
在线用户，在线用户；
字符串user=hm.get（“当前用户”）；
System.out.println（“用户”+用户）；
字符串ip_port=hm.get（用户）；
System.out.println（“ip_端口”+ip_端口）；
//这里我没有得到更新的值
字符串[]ip\u port\u arr=ip\u port.split（“”）；
System.out.println（ip_port_arr[0]）；
InetAddress ia=InetAddress.getByName（ip_port_arr[0]）；
int port=Integer.getInteger（ip_port_arr[1]）；
发送（cryptobj.udpPacketGenerator（在线用户、ia、端口））；
打破
违约：
System.out.println（“恶意数据”）；
打破
}
} 
}捕获（例外e）{
e、 printStackTrace（）；
}   
}
}

我想你需要看一本像Lea的Java并发编程这样的书。一个线程需要成为对象的监视器。然后，所有服务器都可以在HashMap上调用wait（），并在监视器发出notify（）后被唤醒。然后在修改HashMap时，从HashMap的监视器线程调用notifyAll（）。请参阅java.lang.Object notify（）、wait（）和notifyAll（），了解有关如何设置的信息

---

基本上，您必须指定一个线程作为对象的监视器。然后，当notify（）唤醒该线程时，您将通知所有其他线程。

ConcurrentHashMap将对您的情况有所帮助。否则，您可以使用锁并通过这种方式保护对hashMap的访问，更改将对所有线程可见。

为什么不使用RMI？是否会进行并发修改？如果是这样的话，

ConcurrentHashMap

可能会有用。事实上，我对这方面还不熟悉。不确定如何实现RMI或并发修改。我目前正在使用套接字编写java服务器和客户端。服务器将有n个请求，并且每次若用户经过身份验证，服务器将在哈希映射中添加条目。那么，在这个场景中，什么更有帮助以及如何实现它呢？或者我可以根据自己的要求更新上述代码以使其正常工作吗？请参阅下面关于wait（）和notifyAll（）的回答。如果您需要有关如何编写此代码的帮助，请告诉我，我将稍后再查看。这只是可能的方法之一。这是一种低级的方法。还有其他的。确实如此，但是对于低层次的方法，没有太多代码需要实现。谢谢大家。我将实施上述方法。如果您需要帮助，请告诉我。如果你发现它有效，你介意接受这个作为正确答案吗？