锁定是否正确完成

Question

I am reading a UDP feed then decoding it and writing to MSMQ(Message Queuing).

I create a new thread that calls UDPReader. In turn UDPReader creates a threadpool and calls class ipaddrConnection. Run inside ipaddrConnection contains a while loop that continuously reads packets from the Multicast socket and pushes it to class parseUDP. From parseUDP it is decoded and finally pushed to the class that writes to MSMQ. I believe I am not locking the threads properly when it comes to the while loop in ipaddrConnection because threads are attempting to write to the same memory location in MSMQ. I thought that by placing my lock in the while loop, each thread in the pool would have its own time in the "Critical Section" 1.receive a packet then 2.decode and write to MSMQ. I am still learning concurrency and looking for some help. I have provided a crash dump file that I don't understand how to properly read and my UDPReader and ipaddrConnection classes. parseUDP calls a class to decode the packet and that class calls a MSMQ class to write to memory. All of which are in my Critical Section.

class UDPReader implements Runnable
{
    private final String ip, socket, queue, threadName;
    private final JTextArea screen;

    UDPReader(String ip, String socket, String queue, String threadName, JTextArea screen) 
    {
        this.ip = ip;
        this.socket = socket;
        this.queue = queue;
        this.threadName = threadName;
        this.screen = screen;
    }

    public void run()
    {
        screen.append("Thread " + threadName + " running\n\n");
        ExecutorService executor = Executors.newFixedThreadPool(5);
        Runnable reader = new ipaddrConnection(ip, socket, queue);
        executor.execute(reader);
    }

}

public final class ipaddrConnection implements Runnable
{
    private final ReentrantLock lock = new ReentrantLock();
    byte[] bytes = new byte[(int)100000];
    InetAddress group; 
    MulticastSocket s;
    DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
    private String queue;

    public ipaddrConnection(String ip, String socket, String queue) {
        try {
            this.s = new MulticastSocket(Integer.parseInt(socket));
            this.group = InetAddress.getByName(ip);
            this.queue = queue;
        } catch (IOException ex) {
            Logger.getLogger(ipaddrConnection.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

        @Override
        public void run() {
            try {
                parseUDP p = new parseUDP(queue);
                s.joinGroup(group);
                s.setSoTimeout(95000);

                try{
                    while(true){
                        lock.lock();
                        s.receive(packet);
                        p.parseUDP(packet.getData());
                    } 
                }finally {
                    lock.unlock();
                }


             } catch (SocketException ex) {
                Logger.getLogger(ipaddrConnection.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(ipaddrConnection.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

}

Crash Report https://drive.google.com/file/d/0B4GWNCU6_CBlM2tJNGJqNzRVazg/view?usp=sharing

Answer 1

In your code, your locks don't do anything useful.

Each thread has its own lock, so there can be more than one thread using the queue at a time (because Thread 1 locked Lock 1, and Thread 2 locked Lock 2, and there's nothing stopping them using the queue at the same time).

If you make the lock field static in your code, then the threads will all use the same lock.

You might still have problems, because threads never release the lock (unless they encounter an exception) so only one thread will be allowed to do work:

try{
    while(true){
        lock.lock();
        s.receive(packet);
        p.parseUDP(packet.getData());
    } 
}finally {
    lock.unlock();
}

Notice how the only way the thread can unlock the lock is if there's an exception?

You might have wanted something more like this:

while(true) {
    s.receive(packet);
    try {
        lock.lock();
        s.parseUDP(packet.getData());
    } finally {
        lock.unlock();
    }
}

- with this structure, threads will only hold the lock while they are parsing the packets, not while they are receiving packets. (I don't know whether this is what you actually want)

Answer 2

ExecutorService executor = Executors.newFixedThreadPool(5);
Runnable reader = new ipaddrConnection(ip, socket, queue);
executor.execute(reader);

This code is, in effect, single threaded since although the pool has five threads, you are using up only one.

Answer 3

1. Having UDPReader implement Runnable and it's run() implementation is at the very least not idiomatic.
2. As mentioned by immibis your lock objects are not shared between the threads and they don't provide the protection you are looking for.

3. You unlock only when you exit while (true) { ... } which is to say never. With this in mind you may want to consider something like:

     public class UDPReader { ... UDPReader(String ip, String socket, String queue, String threadName, JTextArea screen, numberOfThreads) { ... this.numberOfThreads = numberOfThreads; this.lock = new ReentrantLock(); } public void run() { ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads); for (int i = 0; i < numberOfThreads; i++){ executor.execute(new ipaddrConnection(ip, socket, queue, lock)); } } } public final class ipaddrConnection implements Runnable { private lock ; ... public ipaddrConnection(String ip, String socket, String queue, ReentrantLock lock) { ... this.lock = lock; } @Override public void run() { ... while (true) { try { lock.lock(); s.receive(packet); p.parseUDP(packet.getData()); } finally { lock.unlock(); } } .... } } }