高并发中并行收索时出现两个值相同却判断为false，求大神帮忙解答一下

定义了一个并行收索类：
package thread;

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

public class ConcurrencySearch {
private volatile static AtomicInteger result = new AtomicInteger(-1);
private T searchValue;
private int begin;
private int end;
private CopyOnWriteArrayList array;

public ConcurrencySearch(CopyOnWriteArrayList<T> array,T searchValue,int begin ,int end){
    this.array = array;
    this.searchValue = searchValue;
    this.begin = begin;
    this.end = end;
}

public int getValue(){
    System.out.println(Thread.currentThread().getName());
    for (int i = begin; i < end; i++) {
        System.out.println(Thread.currentThread().getName() +"==>"+i+"-"+array.get(i)+"-"+searchValue+"==?"+(array.get(i) == searchValue));
        if(result.get() > 0){
            return result.get();
        }
        if(array.get(i) == searchValue){
            System.out.println(Thread.currentThread().getName()+"找到了值"+searchValue);
            if(!result.compareAndSet(-1, i)){
                result.get();
            }
            return i;
        }
    }
    return -1;
}

}

然后做了测试用例，发现寻找的数据较小的时候都能够找到，如果稍微大一点就找不到了：
package thread;

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class TEST {
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(5);
final CopyOnWriteArrayList array = new CopyOnWriteArrayList<>();
final int sreachValue = 137;
for (int i = 0; i < 1000; i++) {
array.add(i);
}
long start = System.currentTimeMillis();
ArrayList> fs = new ArrayList<>();
int size = array.size() / 5 + 1;
for (int i = 0, l = 0; i < array.size(); i += size) {
l = i + size;
if(l > array.size()){
l = array.size();
}
final int temp = i;
final int end = l;
FutureTask f = new FutureTask(new Callable() {

            @Override
            public Integer call() throws Exception {
                return new ConcurrencySearch<Integer>(array, sreachValue, temp, end).getValue();
            }
        });
        es.submit(f);
        fs.add(f);
    }
    es.shutdown();
    for (int i = 0; i < fs.size(); i++) {
        try {
            System.out.println(fs.get(i).get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

// System.out.println(System.currentTimeMillis() - start);
}
}

https://www.cnblogs.com/edwardsun/p/3470648.html