Java Threading with MYSQL puzzled

Question

I am very puzzled by the behavior of MySQL and java threading. I declare this as synchronized and the results I get are clashing. That means that more than one thread is accessing the same function at the same time. This code segment is in the runnable class. MachineID is the thread id in the order with which it was invoked in the for loop. (It is jsut a number from 1 to 100).

I don't think the table is required information to

This is the output I get

144 18

144 17

144 11

144 13

144 10

144 9

    public synchronized int getRow() throws SQLException{
        String query="SELECT * FROM Searches WHERE checked='0'";
        ResultSet results = this.database.executeQuery(query);
        int id=0;
        if(results.next()){
            id=results.getInt(1);
            System.out.println(id+" "+this.machineID);
             query = "UPDATE Searches  SET checked='1' WHERE ID_num='"+id+"'";
             System.out.println(this.database.executeUpdate(query));
        }

        return id;
    }
    public void run() {



                int id=getRow();

                if (id!=0) {
}
}

this is where I invoke my threads

for (int i = 0; i < verifier.length; i++) {
        verifier[i]=new Thread(new Verifier(main.database,i+1));
        verifier[i].start();
    }

Show us how you spawn threads. synchronized on the method synchronizes on this. — Sotirios Delimanolis
– Sotirios Delimanolis, Commented Nov 15, 2013 at 2:59
@SotiriosDelimanolis I am not quite sure of what you mean by that, this is how I invoke them. I suppose I make wrong use of syncrhonized but I am not sure what is the right use. — NinjaStars
– NinjaStars, Commented Nov 15, 2013 at 3:02

Sotirios Delimanolis · Accepted Answer · 2013-11-15 03:02:47Z

4

Assuming the getRow() method belongs to the Verifier class, then there is no blocking going on. When you declare synchronized on a method, it is equivalent to synchronizing on the instance itself. However, you are spawning a new Verifier instance for each Thread. Each of those is synchronizing on themselves so none block any of the others.

Consider sharing a Lock object with each instance of Verifier or synchronizing on a shared object.

Object lock = new Object();

for (int i = 0; i < verifier.length; i++) {
    verifier[i]=new Thread(new Verifier(main.database,i+1, lock));
    verifier[i].start();
}

...
public int getRow() throws SQLException{
    synchronized(lock) {
        ...
    }
}

answered Nov 15, 2013 at 3:02

Sotirios Delimanolis

281k62 gold badges718 silver badges744 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

NinjaStars Over a year ago

So there is no point of having a syncrhonize function in a runnable class?

Sotirios Delimanolis Over a year ago

@user2789433 You can reuse the instance as much as you want, so yes, there is a point, in some cases.

Dawood ibn Kareem · Accepted Answer · 2013-11-15 03:13:46Z

0

Sotirios has hit the nail on the head. But instead of having a new variable to lock on, I would use just a single Verifier, and call it from multiple threads. So you'll have

Verifier oneVerifier = new Verifier(main.database, 1);
for (int i = 0; i < verifier.length; i++) {
        verifier[i]=new Thread(oneVerifier);
        verifier[i].start();
}

Note - I don't know what that second argument to the Verifier constructor is supposed to be. Chances are, you don't actually need it, but since you don't actually show the constructor, I thought I'd leave it in.

answered Nov 15, 2013 at 3:13

Dawood ibn Kareem

80.2k15 gold badges102 silver badges112 bronze badges

2 Comments

NinjaStars Over a year ago

I tried what you said, and it didn't work. You can see the edit.

Dawood ibn Kareem Over a year ago

I don't actually understand your edit; but honestly, if you can't get my answer to work, use Sotirios' one. He knows what he's talking about.

Trying · Accepted Answer · 2013-11-15 03:16:38Z

0

No synchronization is happening at all it's is similar to

synchronize(this)

And the same instance is not shared across the threads so there is no synchronization happening at all. So you need to share a lock object across the Runnable instances i.e. Verifier in constructer like:

public class Verifier implements Runnable{
    private final Object lock;
    public Verifier(Object lock){
         this.lock=lock;
    }

Than you can synchronize on the lock like:

synchronize(lock)

else you can synchronize on the class object as well:

synchronize(Verifier.class)

answered Nov 15, 2013 at 3:16

Trying

14.3k11 gold badges72 silver badges113 bronze badges

Collectives™ on Stack Overflow

Java Threading with MYSQL puzzled

3 Answers 3

2 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related