threads do not synchronize

Question

I have some problem about the synchronization of two threads.

This is the main:

public class Main {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new TaskA()).start();
        //Thread.currentThread().sleep(3000);
        new Thread(new TaskB()).start();
    }
}

and these are my two thread that increment/decrement a shared variable "count"

public class TaskA extends Manager implements Runnable {

    @Override
    public void run() {

        while(true){

        try {
            decrement();
            System.out.println("Thread A: " + getCount());
            Thread.sleep((long) Math.random()%4000);
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }
    }
}
public class TaskB extends Manager implements Runnable {
    @Override
    public void run() {
        while(true){
            try {
                increment();

                System.out.println("Thread B: " + getCount());
                Thread.sleep((long) Math.random()%4000);


            }catch(Exception e){
                System.out.println(e.getMessage());
            }
        }
    }
}

Operation are managed by this class:

public class Manager {

    private int count=0;

    public synchronized void increment() throws InterruptedException {
        if(count>=0){
            count++;
        }else {
            wait();
            notifyAll();
        }

    }
    public synchronized void decrement()throws InterruptedException {
        //wait();
        if(count <10){
            count--;
        }else {
            wait();
            notifyAll();
        }

    }
    public synchronized int getCount(){
        return count;

    }}

This is the output that I expect:

-ThreadA: 1 
-ThreadA: 2
-ThreadA: 3
    .
    .
-ThreadB: 10 
-ThreadB: 9
-ThreadB: 8
    .
    .
-ThreadA: 1 
-ThreadA: 2
-ThreadA: 3
    .
    .

Use AtomicInteger instead of private int count=0; in Manager class. — Sambit, May 25 '19 at 07:22
What is your actual output? To begin with, you seem to not share the count variable as each instance of a task has an own copy. — Slawomir Chodnicki, May 25 '19 at 07:25
Different instances of `Manager` with instance level synchronization. Classic bug, must be a duplicate somewhere. — Boris the Spider, May 25 '19 at 08:20

score 1 · Answer 1 · edited May 25 '19 at 08:07

Your count is an instance variable, as is the synchronization mechanism. If you want to share them between different instances, they need to be static:

public class Manager {

    // Made static so that all managers share the same count
    private static int count = 0;

    public void increment() throws InterruptedException {
        // Synchronizing on a resource shared between all instances:
        synchronized (Manager.class) {
            if (count >= 0) {
                count++;
            } else {
                wait();
                notifyAll();
            }
        }
    }

    public void decrement() throws InterruptedException {
        // Synchronizing on a resource shared between all instances:
        synchronized (Manager.class) {
            //wait();
            if (count < 10) {
                count--;
            } else {
                wait();
                notifyAll();
            }
        }
    }

    public int getCount() {
        // Synchronizing on a resource shared between all instances:
        synchronized (Manager.class) {
            return count;
        }
    }}

As Sambit pointed out in the question's comments, I'm surprised you don't use `java.util.concurrent.atomic.AtomicInteger`, a class purpose built for this exact type of situation. — Powerlord, May 25 '19 at 07:34

threads do not synchronize

1 Answers1