java 中能创建 volatile 数组吗

可以创建volatile数组，但是volatile只保证对数组的引用可见，即如果是改变引用只向的数组，将受到volatile的保护，但是对多个线程想要去改变数组里面的元素，volatile不能保证。

package com.youyou;

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by youyou on 2019-11-21.
 */
public class VolatileArrays {

    static volatile int [] arrays={1,1,1,1,1};
    static int x=0;
    static volatile int y=0;
    static volatile AtomicInteger z=new AtomicInteger(0);


    public static void main(String []args) {

        for (int i=0;i<1000;i++){
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    x=x+1;
//                    y=y+1;
//                    z.incrementAndGet();
//                }
//            }).start();
            new Thread(new ChangeNum()).start();

        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Arrays.toString(arrays));
        System.out.println("X:"+x);
        System.out.println("Y:"+y);
        System.out.println("Z:"+z);

    }

     static class ChangeNum implements Runnable{

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            arrays[0]=arrays[0]+1;
            arrays[1]=arrays[1]+1;
            arrays[2]=arrays[2]+1;
            arrays[3]=arrays[3]+1;
            arrays[4]=arrays[4]+1;

            x=x+1;
            y=y+1;
            z.incrementAndGet();
        }
    }
}

运行结果：[970, 978, 982, 984, 985]
X:984
Y:986
Z:1000

从中可以看出volatile不能保证数组中的元素的可见性，并且y=y+1 也是复合操作，不具有原子性。

此处有个问题，如果把ChageArrays的xyz的自加注释掉，放开主代码中的自加，xyz跑出来都是3000，这是为什么？