Java线程同步问题

Question

This is another issue where my code doesn't work, until I add a print statement into the code, which causes everything to work fine. I've been struggling to get my head around thread synchronization lately but its been slow progress. I want a quick fix that can do whatever the print statement does so I can carry on with this. The context is a thread that runs in the server, constantly checking for newly registered users. If the new user doesn't currently exist in the databse, this thread will add it in.

class RecieveThread implements Runnable {

    public void run() {
        while(true) {
            Message msg;
            try {
                msg = comms.receiveUserMessage();
                User newUser;
                newUser = (User)msg.getContents();

                //System.out.println(newUser.getID() + ": " + newUser.getFN());

                for(User user : existingUsers) {
                    if(newUser.getFN().equals(user.getFN()) && newUser.getLN().equals(user.getLN())) {
                        existingUsers.add(user);
                        System.out.println("added: " + newUser.getFN());
                    }
                }
            }catch (ClassNotFoundException | IOException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Comms {
    public Message receiveUserMessage() throws IOException, ClassNotFoundException {
        User user;
        File userMailbox = new File("UserMailbox.txt");
        FileInputStream fis = new FileInputStream(userMailbox);
        ObjectInputStream ois = new ObjectInputStream(fis);

        user = (User)ois.readObject();
        ois.close();

        return new UserMessage(user);
    }
}

public abstract class Message {
    abstract Object getContents();
}

class UserMessage extends Message {
    private User user;

    public UserMessage(User user) {
        this.user = user;
    }

    public User getContents() {
        return this.user;
    }
}


import java.io.Serializable;

public class User implements Serializable {
    private String fn;
    private String ln;
    private int id;
    private char[] pwd;
    private static int userCount = 0;

    public User(String fn, String ln, char[] pwd) {
        this.fn = fn;
        this.ln = ln;
        this.pwd = pwd;
        this.id = ++userCount;
    }

    public String getFN() {
        return fn;
    }

    public String getLN() {
        return ln;
    }

    public char[] getPwd() {
        return this.pwd;
    }

    public int getID() {
        return this.id;
    }
}

Stacktrace:

java.io.EOFException

at java.io.ObjectInputStream$PeekInputStream.readFully(Unknown Source)
at java.io.ObjectInputStream$BlockDataInputStream.readUnsignedShort(Unknown Source)
at java.io.ObjectInputStream$BlockDataInputStream.readUTF(Unknown Source)
at java.io.ObjectInputStream.readString(Unknown Source)
at java.io.ObjectInputStream.readTypeString(Unknown Source)
at java.io.ObjectStreamClass.readNonProxy(Unknown Source)
at java.io.ObjectInputStream.readClassDescriptor(Unknown Source)
at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
at java.io.ObjectInputStream.readClassDesc(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at Comms.receiveUserMessage(Comms.java:40)
at ServerPanel$RecieveThread.run(ServerPanel.java:32)
at java.lang.Thread.run(Unknown Source)
java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at Comms.receiveUserMessage(Comms.java:40)
at ServerPanel$RecieveThread.run(ServerPanel.java:32)
at java.lang.Thread.run(Unknown Source)
java.io.EOFException
at java.io.ObjectInputStream$BlockDataInputStream.peekByte(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at Comms.receiveUserMessage(Comms.java:40)
at ServerPanel$RecieveThread.run(ServerPanel.java:32)
at java.lang.Thread.run(Unknown Source)

Answer 1

Your loop does two things forever.

1. Read a message off the disk.
2. Check (incorrectly) the new user against a list.

As there is no resting ( Thread.sleep() or some form of blocking access) in any of these the loop just spins, never letting any other thread have a time-slice .

Adding the println (which is a blocking method) allows other threads a look-in on the system.

Your mistake in checking the user list - imagine what will happen if the existingUsers list is empty.

Remember that Java implements Cooperative multitasking on a PC with only one core so all threads must give time to others at regular intervals.

It is likely that the message file either does not exist or is empty.

Answer 2

I'd suggest a couple things:

1) Remove the while loop from your ReceiveThread class. Then, where you submit it to a thread pool, use a scheduled one instead, something like:

private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

ReceiveThread rt = new ReceiveThread();
scheduler.scheduleAtFixedRate(rt, 0, YOUR_RATE, TimeUnit.SECONDS);

This will cause it to execute periodically, so you won't have an unchecked loop spinning.

2) For debugging, disable the thread pool and just call ReceiveThread directly instead. Ex:

ReceiveThread rt = new ReceiveThread();
rt.run();

Then you can more easily step through and figure out the exception if needed.

In any case, wrap the ois.readObject() call in a try/catch block to handle the EOFException.

Answer 3

Based on your comment saying a sleep statement 'fixes' it just like a print statement, my guess is that existingUsers is the problem. In your code above you're not doing anything to make it thread-safe. You need something along the lines of:

synchronized (existingUsers)
{
    existingUsers.add(user);
}

You need to do this every time you want to modify existingUsers other than when you initialize it. Here's a brief entry on synchronized . It's more complicated than I'm stating here, but this is a good place to start.

The thing is, print statements take a loooong time. At least, from the computer's perspective. So by having a print statement, you're essentially delaying the execution of the code below. And in your program, this delay seems to be enough to make things run smoothly. I suspect that something is happening with existingUsers elsewhere, but this something happens only once and it happens very early on. By having the delay, you pass over whatever this happens to be and it never causes a problem.

It's common for multi-threaded exceptions to be really difficult to decipher. You're getting an EOFException but that might be a red herring. If you were having problems reading the file, I'd expect that exception every time you run it - not just when a print/sleep statement is in there.

Answer 4

You're trying to read your UserMailbox.txt file while it is still being written by an ObjectOutputStream not shown in the code you gave. Pulling on it endlessly in the while loop causes the problem, and the delay incurred by the System.out.println() is enough for the "pushing" thread to finish writing the file, which becomes ok to read from.

Try to implement a synchronization mechanism to tell your thread that the file has been fully written and is safe to read. If you can't implement such, at least wait for the file to stop being modified before reading it:

File f = new File("UserMailbox.txt");
long t0 = f.lastModified(), t;
Thread.sleep(100);
while ((t = f.lastModified()) != t0) {
    Thread.sleep(100);
    t0 = t;
}

That ugly hack will tell you the file is complete. But you should definitely have another mechanism of telling it is ready (eg send a message).