Java如何正确同步多个线程上的arraylist？

Question

I have a server that creates a thread for each client that connects to it. The main server class is called "Server" while each client is managed by a thread of a class "ClientManager" originating from Server. Server has a static arraylist of tiles (for a mahjong game) and when each client draws, the ClientManager removes that many tiles from the arraylist. I have the method that does this Synchronized (probably incorrectly), but when I run the program, it is as if the first player does not properly remove tiles from the list. When I look at my debug list it says "Player 1 draws, 144 tiles remain" when it should say 131. If I run the program in debug mode, it works perfectly fine. If I add Thread.sleep to the main method in Server that handles all of this, it works, but I don't like the incredibly long wait and would like to have the arraylists just synchronize properly and update properly. The first run should make the list go down by 13, then the next character draws 13 and so on. After that they would each draw 1, but the removing is not being reflected in the game.

Here is the relevant code from the client, server and client manager

Main:

public class Main {
        static GamePanel gameGUI = new GamePanel();
        static Client client;
        static Player me = new Player();
        //!!? is used to mark a username command

    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws IOException{
        String host = "107.199.245.55";
        //String host = "107.199.244.144";
        //String host = "localhost";
        boolean created = false;
        ArrayList<?> Temp = new ArrayList<Object>();
        ArrayList<Tile> TileStack = new ArrayList<Tile>();
        Object object = null;
        int tiles = 0;
        String username = "!!?" + JOptionPane.showInputDialog("Username:");
        if(username.substring(3, username.length()).equals("null")){return;}
        while(username.substring(3, username.length()).isEmpty()){
        username = "!!?" + JOptionPane.showInputDialog("Must have an actual name\nUsername:");
        }
        int port = 27016; 
        //int port = 2626;
        //int port = 4444;


        client = new Client(host, port, username);
        client.send(username);
        gameGUI.initialize();
        gameGUI.lblPlayerNameYou.setText(username.substring(3, username.length()));
        waitForPlayers();

        while(true)
        {
            try {
                object = client.receive();
                if(object instanceof ArrayList<?>)
                {
                    Temp = (ArrayList<?>) object;
                    if(Temp.get(0) instanceof String)
                    {
                        setUpNames(username, Temp);
                    }
                    else if(Temp.get(0) instanceof Tile)
                    {
                        if(!created){
                        TileStack = (ArrayList<Tile>) Temp;
                        created = true;
                        for (int i = 0; i < 13; i++){me.drawOneTile(TileStack);}
                        client.send(13);
                        }
                        else if(created){
                        me.drawOneTile(TileStack);
                        client.send(1);
                        }
                        gameGUI.displayHand(me.hand);
                    }
                }
                else if(object instanceof Integer){
                    tiles = (int) object;
                    gameGUI.tilesRemaining.setText("Remaining Tiles: " + tiles);
                }
            } catch (IOException e) {
                e.printStackTrace();
                JOptionPane.showMessageDialog(null, "You were disconnected. Exiting game.");
                gameGUI.dispose();
                break;
            }
        }

    }

Server:

public class Server {

    public static ArrayList<ObjectOutputStream> ConnectionArray = new ArrayList<ObjectOutputStream>();
    public  ArrayList<String> CurrentUsers = new ArrayList<String>();
    public static ArrayList<Socket> ConnectionArraySOCKET = new ArrayList<Socket>();
    public  ArrayList<Tile> TileStack = new ArrayList<Tile>();
    public static ServerGUI serverGUI;
    public int port;
    public ServerSocket SERVERSOCK;
    public static GameLoop game = new GameLoop();
    public static Server server;

    public Server(int port){
        this.port = port;
        try {
        SERVERSOCK = new ServerSocket(port);
        } catch (IOException e) {
            System.out.println("Unable to start");
            e.printStackTrace();
        }
        serverGUI = new ServerGUI();
        serverGUI.initialize();

    }
    public ArrayList<String> getCurrentUsers(){return CurrentUsers;}
    public ArrayList<Tile> getTileStack(){return TileStack;}
    public void waitForClients(ServerSocket SERVERSOCK)
    {
        serverGUI.addText(serverGUI.getDebugPane(), "Waiting for clients...");

        while(ConnectionArray.size() < 4 && CurrentUsers.size() < 4)
        {
            try{
                if (!(ConnectionArray.size() == 0)) shareToAll(ConnectionArray.size());
                Socket client = SERVERSOCK.accept();
                ConnectionArray.add(new ObjectOutputStream(client.getOutputStream()));
                ConnectionArraySOCKET.add(client);
                Thread t = new Thread(new ClientManager(client));
                t.start();
                if (!(ConnectionArray.size() == 0)) shareToAll(ConnectionArray.size());
            }
            catch(IOException e){e.printStackTrace();}
        }
    }

    public static void shareToAll(Object o){
        for(ObjectOutputStream stream : ConnectionArray)
        {
            try{
            Thread.sleep(100);
            stream.writeObject(o);
            stream.reset();
            stream.flush();
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void distributeTileStack(Object o, int playerNum){
        try {
            ConnectionArray.get(playerNum).writeObject(o);
            ConnectionArray.get(playerNum).reset();
            ConnectionArray.get(playerNum).flush();
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static boolean checkConnection()
    {
        if(ConnectionArray.size() < 4) return false;
        else return true;
    }



    public static void main(String[] args) throws InterruptedException
    {   
        server = new Server(Integer.parseInt(JOptionPane.showInputDialog("Port:")));
        ArrayList<Tile> temp = new ArrayList<Tile>();
        while(!serverGUI.started){
            System.out.println("LOOP");
        }

        server.waitForClients(server.SERVERSOCK);
        Server.shareToAll(server.getCurrentUsers());

        game.createStack();
        server.TileStack = game.getStack();
        for (int i = 0; i <= 3; i++){
            serverGUI.addText(serverGUI.getDebugPane(), "Player " + (i + 1) + " drawing tiles.");
            temp = server.getTileStack();
            Server.distributeTileStack(server.TileStack, i);            
            serverGUI.addText(serverGUI.getDebugPane(), "Tilestack size: " + server.getTileStack().size());
            Server.shareToAll(server.getTileStack().size());
        }

        while(checkConnection()){
            // game logic here


        }

        JOptionPane.showMessageDialog(null, "Player disconnected. The server will now close.");
        serverGUI.btnStopServer.doClick();
        serverGUI.dispose();


    }
}

ClientManager:

public class ClientManager extends Thread implements Runnable {

    Socket SOCK;
    String username;
    public ClientManager(Socket SOCK)
    {
        this.SOCK = SOCK;
    }

    public void run(){
        boolean working = true;
        try{
            ObjectInputStream inStream = new ObjectInputStream(SOCK.getInputStream());
            while(working){
                working = handle(inStream);
            }
        }
        catch(SocketException e){
            e.printStackTrace();
            System.out.println("Cannot get inputstream");
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }
    public boolean handle(ObjectInputStream inStream){
        Object object = null;
        String string;
        try{
            object = inStream.readObject();
            if(object instanceof String)
            {
                string = (String)object;
                if(string.startsWith("!!?")){
                username = string.substring(3, string.length());
                synchronized (Server.class){
                Server.server.CurrentUsers.add(username);
                }
                Server.serverGUI.addText(Server.serverGUI.getDebugPane(), "User connected: " + username + SOCK.getRemoteSocketAddress());
                Server.serverGUI.addText(Server.serverGUI.getUsersPane(), username);
                Server.serverGUI.addText(Server.serverGUI.getDebugPane(), "Number of users: " + Server.server.CurrentUsers.size());
                }

            }
            if (object instanceof Integer)
            {
                synchronized(Server.class){
                    for (int i = 0; i < (int) object; i++)
                        Server.server.TileStack.remove(0);
                }
            }
        }
        catch(ClassNotFoundException ce){ce.printStackTrace();}
        catch(IOException e){
            e.printStackTrace();
            for(int i = Server.ConnectionArray.size() - 1; i >= 0; i--)
            {
                if(Server.ConnectionArraySOCKET.get(i).equals(SOCK))
                {
                    Server.serverGUI.addText(Server.serverGUI.getDebugPane(), "User " + Server.server.CurrentUsers.get(i) + SOCK.getRemoteSocketAddress() + " disconnected");
                    Server.serverGUI.clearText(Server.serverGUI.getUsersPane());
                    Server.server.CurrentUsers.remove(i);
                    Server.serverGUI.addText(Server.serverGUI.getDebugPane(), "Number of users: " + Server.server.CurrentUsers.size());
                    Server.ConnectionArraySOCKET.remove(i);
                    Server.ConnectionArray.remove(i);
                    for (int i2 = 1; i2 <= Server.server.CurrentUsers.size(); i2++){
                        Server.serverGUI.addText(Server.serverGUI.getUsersPane(), Server.server.CurrentUsers.get(i2-1));
                    }
                    if (!(Server.ConnectionArray.size() == 0)) Server.shareToAll(Server.ConnectionArray.size());
                }


            }
            return false;

        }
        return true;
    }

}

Answer 1

Create an interface whose implementation enforces a single instance of your list (singleton).

Example interface

interface SharedResource<T>{ 
   public void add(T);
   public T remove();
}

In it's implementation enforce a single instance

   public List<Item> getInstance(){

        if(myList == null){
             myList = Collections.synchronizedList(TileStack);
        }

      return myList;

    }

This way you can be sure each client is using the same list, this will eliminate each client having their own copy of a synchronized list.

Better Description

Or if you just want to make a class

public class MyResource{
    List<Item> myList;
    private MyResource(){}

    public List<Item> getInstance(){

        if(myList == null){
             myList = Collections.synchronizedList(new ArrayList<Item>());
        }

        return myList;

    }
}

Answer 2

You can simplify this as follows:

private ArrayDeque<Tile> tiles;
private ConcurrentHashMap<Integer, ArrayList<Tile>> preallocate;

private void preAllocate() {
    for(int i = 0; i < 4; i++) {
        ArrayList<Tile> temp = new ArrayList<>();
        for(int j = 0; j < 13; j++) {
            temp.add(tiles.pop());
        }
        preallocate.put(i, temp);
    }
}

public ArrayList<Tile> get(int playerId) {
    return preallocate.get(playerId);
}

You preallocate all of the players' hands in a single thread, so you don't need synchronization. You then use a thread-safe ConcurrentHashMap to store the players' hands so that again you don't need synchronization (the map takes care of that).

An alternative is to replace the ArrayList<tile> with a ConcurrentLinkedQueue<Tile> , where again you don't need to worry about synchronization because the data structure is handling it for you. Note however that this implementation would be "cheating" in that Player1 might not get the first 13 tiles, Player2 might not get the second 13 tiles, and so on - the tile allocation would be non-deterministic. However, I'm assuming that you're shuffling the tiles, in which case it shouldn't make any difference what order the players draw in. If this would be unacceptable then I'd recommend going with the preallocated ConcurrentHashMap (you could also accomplish this with the ConcurrentLinkedQueue , but it would be just as complicated as using a global ArrayList )