CODEWITHSUNDEEP
javamultithreadingdeadlock
nicomp
nicomp

Reputation: 4647

Will this code deadlock if it runs long enough?

This contrived project will eventually deadlock, won't it?

Two methods are synchronized in a shared object. The two threads will eventually find themselves in one of those methods and trying to invoke the other method. I think.

package main;

import java.util.ArrayList;
import java.util.List;

import myThread.MyThread;
import sharedObject.SharedObject;
import uncooperativeThread.UncooperativeThread;

public class Main {

    public static void main(String[] args) {
        competingThreads();
        //uncooperativeThreads();
        
    }
    private static void competingThreads() {
        List<MyThread> myThreads = new ArrayList<MyThread>();
        SharedObject sharedObject = new SharedObject();
        int threads = 2;
        for (int i = 0; i < threads; i++) {
            myThreads.add(new MyThread(i, sharedObject));
        }

        for (MyThread t : myThreads) {
            t.start();
        }

        for (MyThread t : myThreads) {
            try {t.join();} catch (Exception ex) {}
        }
    }
    /**
     * We will try to call SharedObject.methodC from two threads. The first one will get in, the second will have to wait.
     */
    private static void uncooperativeThreads() {
        SharedObject sharedObject = new SharedObject();
        UncooperativeThread t1 = new UncooperativeThread(1, sharedObject);
        UncooperativeThread t2 = new UncooperativeThread(2, sharedObject);
        
        t1.start();
        t2.start();
        
        try {t1.join();} catch (Exception ex) {}
        try {t2.join();} catch (Exception ex) {}
    }
}


package myThread;

import sharedObject.SharedObject;

public class MyThread extends Thread {
    private int id;
    SharedObject sharedObject;
    
    public MyThread(int id, SharedObject sharedObject) {
        this.id = id;
        this.sharedObject = sharedObject;   // Reference
        
    }
    public void run() {
        doStuff();
    }
    private void doStuff() {
        int counter = 0;
        while (true) {
            System.out.println(++counter);
            if (id % 2 == 1) {
                sharedObject.methodA(id);
            } else {
                sharedObject.methodB(id);
            }
        }       
    }
}

package sharedObject;

import java.util.Random;

public class SharedObject {
    public synchronized void methodA(int id) {
        //System.out.println("methodA(): Thread " + id);
        try {Thread.sleep((new Random()).nextInt(1000));} catch(Exception ex) {}
        if (id == 0) {return;}
        // What I want is for one thread to try to call methodB() while the *other* thread is in methodB() trying to call methodA(). 
        methodB(id);
    }
    
    public synchronized void methodB(int id) {
        //System.out.println("methodB(): Thread " + id);
        try {Thread.sleep((new Random()).nextInt(1000));} catch(Exception ex) {}
        if (id == 1) {return;}
        methodA(id);
    }
}

Upvotes: 0

Views: 58

Answers (1)

Solomon Slow
Solomon Slow

Reputation: 27190

// What I want is for one thread to try to call methodB() while the other thread is in methodB() trying to call methodA().

That's not a deadlock. The thread that's trying to call methodB() simply will be forced to wait until the other thread releases the lock by returning from its methodB() call.

To get a classic deadlock, you need to have two locks. Your program has only one lock—the intrinsic lock belonging to the single instance of SharedObject that your program creates.

A classic deadlock is when one thread has already acquired lock A and is waiting to acquire lock B while the other thread has acquired lock B, and it's waiting to acquire lock A. In that case, neither thread can make progress until the other thread releases its lock. But, neither thread will release its lock because neither thread can make progress.

You need two locks. You have two methods (methodA() and methodB()), but they both lock the same lock.

Upvotes: 1

Related Questions