这个Java线程程序有什么问题

Question

I am trying to figure out what is wrong with this thread program in java. Can anyone shed some light? Here is the code:

public class Z {
    private Account account = new Account();
    private Thread[] thread = new Thread[100];

    public static void main(String[] args) {
        Z test = new Z();
        System.out.println("What is balance ? " + test.account.getBalance());
    }

    public Z() {
        ThreadGroup g = new ThreadGroup("group");
        boolean done = false;

        // Create and launch 100 threads
        for (int i = 0; i < 100; i++) {
            thread[i] = new Thread(g, new AddAPennyThread(), "t" + i);
            thread[i].start();
            System.out.println("depositor: " + thread[i].getName());
        }
        // Check if all the threads are finished
        while (!done)
            if (g.activeCount() == 0)
                done = true;
    }

    // A thread for adding a penny to the account
    class AddAPennyThread extends Thread {
        public void run() {
            account.deposit(1);
        }
    }

    // An inner class for account
    class Account {
        private int balance = 0;

        public int getBalance() {
            return balance;
        }

        public void deposit(int amount) {
            int newBalance = balance + amount;
            balance = newBalance;
        }
    }
}

It compiles and runs fine. It was a test question I missed and wnated to know what is actually wrong with it. Thanks!

Answer 1

There is not a single bit dedicated to synchronization of 100 threads all working on exactly one (1!!!) piece of data.

Anything can happen. "Anything" includes that the code as it is works most of the time due some "coincidences":

• The task at hand is quite small. (only an add)
• The tasks are created and immediately started.
• There is a small delay between two "create+start" pair: the System.out.println .

This adds up to: This might work in most test-runs. But it is an incorrect and non-deterministic program.

Answer 2

[Tread1] int newBalance = balance + amount;
[Tread2] int newBalance = balance + amount;
[Tread1] balance = newBalance;
[Tread2] balance = newBalance;

public synchronized void deposit(int amount)

Answer 3

balance should be a private volatile int (so that Java knows to never cache it - its value is liable to change between different thread accesses without the next thread knowing) and make Account#deposit(int amount) a public synchronized void (so that Java makes the method body a critical region and prevents simultaneous access of any of the objects it touches, ensuring the integrity of the value of balance ).

Additionally, instantiating 100 threads yourself with new introduces a lot of overhead - though I appreciate this is just a toy example, a more efficient way to do this would be to use a Java thread pool .