使用3个线程将元素添加到5个ArrayList中：arraylist大小的总和总是不同的

Question

The Company class contains 5 ArrayList, that I'm trying to update with 3 threads. The addToWorkers() method gets the type of the Employee subclasses, and adds them to the corresponding array. I'm using the LazyHolder class because my Company singleton instance has to be static, and it should provide synchronization.

public class Company {

    private static class LazyHolder {
        private static final Company INSTANCE = new Company();
}

    private volatile List<ProjectLeader> projectLeaders = new ArrayList<>();
    private volatile List<ConsultantLeader> consultantLeaders = new ArrayList<>();
    private volatile List<DeveloperLeader> developerLeaders = new ArrayList<>();
    private volatile List<DeveloperWorker> developerWorkers = new ArrayList<>();
    private volatile List<ConsultantWorker> consultantWorkers = new ArrayList<>();

    private Company() {
    }

    public static Company getInstance() {
        return LazyHolder.INSTANCE;
    }

    public synchronized <T extends Employee> void addToWorkers(T t) {
        Position p = t.getPosition();
        switch (p) {
            case DEVELOPER_WORKER: Company.getInstance().developerWorkers.add((DeveloperWorker) t);
                break;
            case DEVELOPER_LEADER: Company.getInstance().developerLeaders.add((DeveloperLeader) t);
                break;
            case CONSULTANT_WORKER: Company.getInstance().consultantWorkers.add((ConsultantWorker) t);
                break;
            case CONSULTANT_LEADER: Company.getInstance().consultantLeaders.add((ConsultantLeader) t);
                break;
            case PROJECT_LEADER: Company.getInstance().projectLeaders.add((ProjectLeader) t);
                break;
        }
    }
}

The Runner class implements the Runnable interface:

public class Runner implements Runnable {

    private Random random = new Random();
    private Position[] positions = Position.values();

    final Position randomPosition(){
        return positions[random.nextInt(positions.length)];
    }

    public void run() {
        for (int i = 1; i <= 350; i++) {
            Position p = randomPosition();
            switch (p) {
                case PROJECT_LEADER:
                Company.getInstance().addToWorkers(new ProjectLeader(p, "projectLeader"));
                    break;
                case DEVELOPER_LEADER:
                Company.getInstance().addToWorkers(new DeveloperLeader(p, "developerLeader"));
                    break;
                case CONSULTANT_LEADER:
                    Company.getInstance().addToWorkers(new ConsultantLeader(p, "consultantLeader"));
                    break;
                case DEVELOPER_WORKER:
                Company.getInstance().addToWorkers(new DeveloperWorker(p, "developerWorker"));
                    break;
                case CONSULTANT_WORKER:
                Company.getInstance().addToWorkers(new ConsultantWorker(p, "consultantWorker"));
                    break;
            }
        }
    }
}

Since all the List type variables are volatile and the method I'm using is synchronized I'd expect, that if I run my main method, and get the sum of the size of each array, I'd get exactly 1050 each time, but I dont, it's always between 1000-1100, or sometimes ArrayIndexOutOfBoundsException :

    t1.start();
    t2.start();
    t3.start();
    try {
        t1.join();
        t2.join();
        t3.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println(Company.getInstance().getConsultantLeaders().size() +
            Company.getInstance().getDeveloperWorkers().size() +
            Company.getInstance().getConsultantLeaders().size() +
            Company.getInstance().getDeveloperLeaders().size() +
            Company.getInstance().getProjectLeaders().size());

What am I missing here?

Answer 1

According to your logic there is no reason to make your lists visible for all threads,

public synchronized <T extends Employee> void addToWorkers(T t) 

is enough to make it thread safe, but with this way there is no point to use multithreading.

I suggest you to define your lists like this :

private  List<ProjectLeader> projectLeaders = Collections.synchronizedList(new ArrayList<>());
private  List<ConsultantLeader> consultantLeaders = Collections.synchronizedList(new ArrayList<>());
private  List<DeveloperLeader> developerLeaders = Collections.synchronizedList(new ArrayList<>());
private  List<DeveloperWorker> developerWorkers = Collections.synchronizedList(new ArrayList<>());
private  List<ConsultantWorker> consultantWorkers = Collections.synchronizedList(new ArrayList<>());

Now we can solve your real problem , this one is funny :)

Check your sum, you are not adding to consultantworkers to the sum, you are adding consultant leaders for twice :

 System.out.println(
        Company.getInstance().getConsultantLeaders().size() + // leaders
        Company.getInstance().getDeveloperWorkers().size() +
        Company.getInstance().getConsultantLeaders().size() +//this one must be workers 
        Company.getInstance().getDeveloperLeaders().size() +
        Company.getInstance().getProjectLeaders().size()); 

you need also workers ;)