java - 当 A Thread(list.add()) 和 B Thread(list.size()) 工作时，这条线如何工作？

Question

有两个线程，A线程让列表添加十次，B线程会在list.size() > 5时退出。我认为结果应该是“B会在A添加5后退出，也许6,7 ，7,8,9”，但结果是B始终没有放弃。另一个问题是当我在那里添加一行时，就可以了!为什么？

package com.lock;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Create by @author Henry on 2018/5/4
 */
public class NoWait {
    static volatile ArrayList list = new ArrayList();
    public static void main(String[] args) throws InterruptedException {

        ThreadA a = new ThreadA(list);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(list);
        b.setName("B");
        b.start();

        Thread.sleep(10000);
        System.out.println("A is " + a.isAlive());
        System.out.println("B is " + b.isAlive());
    }
}

class ThreadA extends Thread{
    private ArrayList list;
    public ThreadA(ArrayList list){
        this.list = list;
    }

    @Override
    public void run(){
        try{
            for (int i = 0; i < 10; i++) {
                list.add(i);
                System.out.println("=====================================add "+(i+1));
                Thread.sleep(100);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("A finished");
    }
}

class ThreadB extends Thread{
    String s = "";
    private ArrayList list;
    public ThreadB(ArrayList list){
        this.list = list;
    }

    @Override
    public void run(){
        try{
            while(true){
                //s += list.size();
                //System.out.println(list.size());
                if(list.size() > 5){
                    System.out.println(">5 now, B gonne quit");
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果是B线程永远不会停止!这是我的第一个问题。

第二个是，当我添加此行时

//s += list.size();
//System.out.println(list.size());

一切都会好起来的，为什么？!!他们是如何工作的!

Answer 1

线程 B 不能保证看到线程 A 的任何更改，因为它们之间没有同步。

Volatile 在这里不会执行任何操作，因为它仅确保对列表的引用对两个线程都可见，但不会更新其内容。

println 具有内部同步，这使得线程之间的变化可见。