Proper way of truncating a synchronized ArrayList in Java

I have a Java ArrayList that a process is filling it up with data:

synchronized (transferredFilesList) {
	transferredFilesList.add(transferredFilesDataEvent);
}

I have another process that empties this list in such a way that, if the number of records in the list does not exceed 2500, it will remove all entries, but if the number of entries is greater than 2500, it should truncate the list so that the first 2500 entries are removed. I'm doing the truncation like this:

List<LinkedHashMap<String, Object>> tempTransferredFilesList;
synchronized (transferredFilesList) {
	logger.info("Transferred files list size: " + transferredFilesList.size());
	if(transferredFilesList.size() < 2500){
		tempTransferredFilesList = transferredFilesList;
		transferredFilesList = new ArrayList<LinkedHashMap<String, Object>>();
	}else{
		tempTransferredFilesList = new ArrayList<LinkedHashMap<String, Object>>();
		tempTransferredFilesList = transferredFilesList.subList(0, 2500);
		transferredFilesList = transferredFilesList.subList(2500, transferredFilesList.size());
	}
}

But, whenever I exceed 2500 records, I'm getting a "java.util.ConcurrentModificationException", meaning that the code in the "else" block is not correct. What is the proper way of truncating a synchronized list, without iterating and removing the elements one by one?

The problem you've got here is that you're reassigning the thing you are synchronizing on. As soon as you do that, synchronized blocks are no longer waiting on the same monitor.

The easiest way to deal with this is to avoid the reassignment, by truncating the head of the list:

List<T> head = new ArrayList<>(list.subList(0, 2500));
list.subList(0, 2500).clear();

This doesn't create a new list, it just chops everything up to element 2500.