CountDownLatch实例

最新推荐文章于 2020-07-13 20:28:21 发布
最新推荐文章于 2020-07-13 20:28:21 发布
阅读量118 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43648977/article/details/101216728
版权

package com.kyexpress.common.data.connect.provider.service;

import java.io.IOException;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.elasticsearch.client.RestHighLevelClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.kyexpress.common.data.connect.api.model.CompareRelation;
import com.kyexpress.common.data.connect.api.model.CompareResult;
import com.kyexpress.common.data.connect.api.model.CompareSource;
import com.kyexpress.common.data.connect.api.model.CompareTask;
import com.kyexpress.common.data.connect.api.model.DataSource;
import com.kyexpress.common.data.connect.api.model.JobInfo;
import com.kyexpress.common.data.connect.api.model.JobInfoItem;
import com.kyexpress.common.data.connect.api.model.ResourceTable;
import com.kyexpress.common.data.connect.provider.constant.ResponseCode;
import com.kyexpress.common.data.connect.provider.enums.CompareResultType;
import com.kyexpress.common.data.connect.provider.utils.CompareResultHelper;
import com.kyexpress.common.data.connect.provider.utils.ElasticUtils;
import com.kyexpress.common.data.connect.provider.utils.ObjectNodeListHandler;
import com.kyexpress.common.data.connect.provider.utils.Tools;
import com.kyexpress.common.data.connect.provider.utils.compare.DbCompareTask;
import com.kyexpress.common.data.connect.provider.utils.compare.EsCompareTask;
import com.kyexpress.common.data.worker.util.JobInfoHelper;
import com.kyexpress.common.data.worker.util.JobInfoItemHelper;
import com.kyexpress.common.data.worker.util.ResourceTableHelper;
import com.kyexpress.framework.exception.ApplicationException;
import com.kyexpress.framework.utils.Context;
import com.kyexpress.framework.utils.ContextUtils;
import com.kyexpress.framework.utils.EncryptUtils;
import com.zaxxer.hikari.HikariDataSource;

@Service(“compareDbAndEsService”)
public class CompareDbAndEsService {
private static final Logger LOGGER = LoggerFactory.getLogger(CompareDbAndEsService.class);

@Autowired
@Qualifier("compareTaskExecutor")
private ThreadPoolTaskExecutor compareTaskExecutor;

@Autowired
private JobInfoService jobInfoService;

@Autowired
private WorkerNodeJobService workerNodeJobService;

@Autowired
private ObjectMapper objectMapper;

@Autowired
private DataSourceService dataSourceService;

@Autowired
private CompareSourceService compareSourceService;

@Autowired
private CompareRelationService compareRelationService;

@Autowired
private ObjectNodeListHandler objectNodeListHandler;

@Autowired
private CompareResultService compareResultService;

@Autowired
private CompareTaskService compareTaskService;

@Autowired
private ElasticsearchHightService elasticsearchService;

@Async("compareTaskExecutor")
@Transactional(propagation = Propagation.SUPPORTS)
public void dbCompareEs(final CompareRelation compareRelation, final Context context) {
	Long beginTime = System.currentTimeMillis();
	ContextUtils.set(context);
	final CompareTask compareTask;
	try {
		compareTask = compareTaskService.get(compareRelation.getCompareTaskId());
	} catch (Exception e) {
		// 正常情况下，都需要查到对比任务相关信息
		LOGGER.error(e.getMessage(), e);
		return;
	}
	// 基础数据构建
	Long batchId = compareRelation.getCompareBatchId();
	final JobInfo jobInfo = jobInfoService.get(compareTask.getJobId());
	workerNodeJobService.fillJobInfo(jobInfo);
	final Map<Long, DataSource> dbDataSourceMap = getDBDataSourceMap(jobInfo);
	final Map<Long, HikariDataSource> connectionMap = getConnectionMap(dbDataSourceMap);
	Map<String, List<DataSource>> dataMap = dataSourceMap(dbDataSourceMap);
	List<Thread> threads = Lists.newArrayList();
	try {
		final JobInfoHelper jobInfoHelper = JobInfoHelper.newInstance(objectMapper, jobInfo);
		int dbMaxSize = 9;
		// 10库100表
		CountDownLatch latch = new CountDownLatch(1000);
		// 循环库
		for (int i = 0; i <= dbMaxSize; i++) {
			int finalI = i;
			Thread thread = new Thread(() -> {
				compareSourceIds(compareTaskExecutor, latch, compareRelation, compareTask, batchId, finalI, jobInfo,
						dataMap, jobInfoHelper, connectionMap);
			});
			thread.start();
			threads.add(thread);
		}
		latch.await();
		compareRelation.setCompareBatchStatus(CompareRelation.COMPARE_BATCH_STATUS_FINISH);
		compareRelation.setExceptionValue("");
		updateBatchStatus(compareRelation);
	} catch (Exception e) {
		compareRelation.setCompareBatchStatus(CompareRelation.COMPARE_BATCH_STATUS_EXCEPTION);
		compareRelation.setExceptionValue(StringUtils.substring(ExceptionUtils.getStackTrace(e), 0, 65535));
		try {
			updateBatchStatus(compareRelation);
		} catch (Exception e1) {
			LOGGER.error(e1.getMessage(), e1);
		}
		LOGGER.error(e.getMessage(), e);
	} finally {
		close(connectionMap.values());
		for (Thread thread : threads) {
			thread.interrupted();
		}
	}
	LOGGER.info("任务名称:{},执行结束,共耗时{}毫秒->", compareTask.getCompareTaskName(),
			(System.currentTimeMillis() - beginTime));
}

// 关闭数据源连接
private void close(Collection<HikariDataSource> values) {
	for (HikariDataSource dataSource : values) {
		IOUtils.closeQuietly(dataSource);
	}
}

// 关闭es连接
private void closeEsClient(RestHighLevelClient elasticSearchClient) {
	try {
		if (null != elasticSearchClient) {
			elasticSearchClient.close();
		}
	} catch (Exception e) {
		LOGGER.error(e.getMessage(), e);
	}
}

// 按照库进行处理
private void compareSourceIds(ThreadPoolTaskExecutor compareTaskExecutor, CountDownLatch latch,
		CompareRelation compareRelation, CompareTask compareTask, Long batchId, int dbNumber, JobInfo jobInfo,
		Map<String, List<DataSource>> dataMap, JobInfoHelper jobInfoHelper,
		Map<Long, HikariDataSource> connectionMap) {
	// 根据ids 循环00-99表查询数据
	for (int i = 0; i <= 99; i++) {
		try {
			if (!CompareRelation.COMPARE_BATCH_STATUS_RUN
					.equals(compareRelationService.getCompareBatchStatus(compareRelation))) {
				continue;
			}
			// 根据表和库获取数据
			String sourceTable = String.format("%02d", i);
			String sourceDb = String.valueOf(dbNumber);
			String sourceId = String.valueOf(batchId).concat("-").concat(sourceDb).concat(sourceTable);
			String tableName = "compare_source".concat(sourceDb).concat(sourceTable);
			int pageSize = 256;
			int num = 1;
			while (true) {
				List<CompareSource> list = compareSourceService.selectCompareSourceList(sourceId,
						(num - 1) * pageSize, pageSize, tableName);
				if (list.isEmpty()) {
					break;
				}
				List<String> ids = list.stream().map(CompareSource::getCompareValue).collect(Collectors.toList());
				compareData(compareTaskExecutor, compareTask, batchId, compareRelation, ids, jobInfo, dbNumber, i,
						dataMap, jobInfoHelper, connectionMap);
				// 大于256继续循环下去
				if (list.size() < pageSize) {
					break;
				}
				num++;
			}
		} catch (Exception e) {
			LOGGER.error(e.getMessage(), e);
			throw new ApplicationException(ResponseCode.COMPARE_TASK_EXCEPTION);
		} finally {
			latch.countDown();
			LOGGER.info("CountDown大小：{}->", latch.getCount());
		}
	}
}

private List<CompareResult> getCompareResultList(List<String> ids, Long taskId, Long barchId) {
	List<CompareResult> compareResultList = Lists.newArrayList();
	CompareResult compareResult = null;
	for (String compareId : ids) {
		compareResult = new CompareResult();
		compareResult.setCompareTaskId(taskId);
		compareResult.setCompareBatchId(barchId);
		compareResult.setCompareId(compareId);
		compareResultList.add(compareResult);
	}
	return compareResultList;

}

/**
 * 根据库下表和表下标获取相对应的数据id
 * 
 * @param taskId
 * @param batchId
 * @param compareRelation
 * @param elasticSearchClient
 * @param ids
 * @param jobInfo
 * @param dbNumber
 * @param tableNumber
 * @param dataMap
 * @param jobInfoHelper
 * @param connectionMap
 */
private void compareData(ThreadPoolTaskExecutor compareTaskExecutor, CompareTask compareTask, Long batchId,
		CompareRelation compareRelation, List<String> ids, JobInfo jobInfo, int dbNumber, int tableNumber,
		Map<String, List<DataSource>> dataMap, JobInfoHelper jobInfoHelper,
		Map<Long, HikariDataSource> connectionMap) {
	final long batchBeginTime = System.currentTimeMillis();
	final List<Future<Object>> futureList = new LinkedList<>();
	// 根据ids 查询es数据
	final List<CompareResult> compareResultList = getCompareResultList(ids, compareTask.getId(), batchId);
	final Map<String, CompareResultHelper> compareResultMap = getCompareResultMap(compareResultList);
	// 根据库获取 到对应的数据源
	List<DataSource> dataSources = dataMap.get(String.valueOf(dbNumber));
	final RestHighLevelClient elasticSearchClient = getESClient(jobInfo);
	final CompletionService<Object> completionService = new ExecutorCompletionService<>(compareTaskExecutor);
	try {
		// 数据源并行处理
		// 查询db数据
		futureList.add(completionService.submit(new EsCompareTask(elasticSearchClient, jobInfo, compareResultMap)));
		for (DataSource vo : dataSources) {
			futureList.add(completionService.submit(new DbCompareTask(connectionMap, compareTaskExecutor, vo,
					objectNodeListHandler, objectMapper, jobInfoHelper, compareResultMap, tableNumber)));
		}
		for (Future<Object> future : futureList) {
			future.get();
		}
		// 生成 DB Data
		for (CompareResultHelper compareResultHelper : compareResultMap.values()) {
			final ObjectNode dbData = objectMapper.createObjectNode();
			final ObjectNode showDBData = objectMapper.createObjectNode();
			int dbCount = 0;
			for (Long tableId : compareResultHelper.getRowMap().keySet()) {
				final ResourceTableHelper resourceTableHelper = jobInfoHelper.getResourceTableHelper(tableId);
				for (ObjectNode row : compareResultHelper.getRowMap().get(tableId)) {
					final String schema = Tools.asText(row, "schema", "unknown");
					final String table = Tools.asText(row, "table", "unknown");
					final JsonNode data = row.get("data");
					resourceTableHelper.setValue(dbData, data, null, "INSERT");
					dbCount++;

					ObjectNode schemaNode = (ObjectNode) showDBData.get(schema);
					if (schemaNode == null) {
						schemaNode = showDBData.objectNode();
						showDBData.set(schema, schemaNode);
					}
					ArrayNode tableNode = (ArrayNode) schemaNode.get(table);
					if (tableNode == null) {
						tableNode = schemaNode.arrayNode();
						schemaNode.set(table, tableNode);
					}
					tableNode.add(data);
				}
			}
			compareResultHelper.setShowDBData(showDBData);
			compareResultHelper.setDBData(dbData);
			compareResultHelper.getCompareResult().setCompareDbNum(Long.valueOf((long) dbCount));
		}
		final List<CompareResult> insertList = new LinkedList<>();
		for (CompareResultHelper compareResultHelper : compareResultMap.values()) {
			compare(jobInfoHelper, compareResultHelper);
			final CompareResult compareResult = compareResultHelper.getCompareResult();
			if (!CompareResult.COMPARE_STATUS_EQUAL.equals(compareResult.getCompareStatus())) {
				compareResult.setId(null);
				insertList.add(compareResult);
			}
		}
		if (!insertList.isEmpty()) {
			if (CompareResultType.ES.getCode().equals(compareTask.getCompareResultType())) {
				// 存储es
				elasticsearchService.insertBatchCompareResult(insertList);
			} else {
				// 存储mysql
				compareResultService.insertBatch(insertList);
			}
		}
		final long batchEndTime = System.currentTimeMillis();
		if (LOGGER.isInfoEnabled()) {
			LOGGER.info("[compareDbAndEsService][compare]ES-DB数据耗时{}毫秒", (batchEndTime - batchBeginTime));
		}
	} catch (Exception e) {
		throw new ApplicationException(ResponseCode.COMPARE_TASK_EXCEPTION);
	} finally {
		closeEsClient(elasticSearchClient);
	}
}

/**
 * 根据比对任务获取抽取任务所关联的数据源
 * 
 * @param dbDataSourceMap
 * @return
 */
private Map<Long, HikariDataSource> getConnectionMap(final Map<Long, DataSource> dbDataSourceMap) {
	final Map<Long, HikariDataSource> connectionMap = new ConcurrentHashMap<>(dbDataSourceMap.size() * 2);
	for (DataSource dbDataSource : dbDataSourceMap.values()) {
		HikariDataSource hikariDataSource = new HikariDataSource();
		hikariDataSource.setDriverClassName("com.mysql.jdbc.Driver");
		hikariDataSource.setMaximumPoolSize(64);
		hikariDataSource.setMinimumIdle(0);
		hikariDataSource.setUsername(dbDataSource.getDataSourceUser());
		hikariDataSource.setPassword(EncryptUtils.aesDecrypt(dbDataSource.getDataSourcePasswd()));
		hikariDataSource.setJdbcUrl(dbDataSource.getDataSourceAddress());
		connectionMap.put(dbDataSource.getId(), hikariDataSource);
	}
	return connectionMap;
}

/**
 * 更新状态
 * 
 * @param compareRelation
 */
private void updateBatchStatus(final CompareRelation compareRelation) {
	final Long compareTaskId = compareRelation.getCompareTaskId();
	final Long compareBatchId = compareRelation.getCompareBatchId();

	final CompareRelation dbCompareRelation = getByCompareTaskIdAndCompareBatchId(compareTaskId, compareBatchId);
	final CompareRelation updateCompareRelation = new CompareRelation();
	updateCompareRelation.setId(dbCompareRelation.getId());
	updateCompareRelation.setCompareBatchStatus(compareRelation.getCompareBatchStatus());
	updateCompareRelation.setExceptionValue(compareRelation.getExceptionValue());

	compareRelationService.updateSelective(updateCompareRelation);

	final CompareTask updateCompareTask = new CompareTask();
	updateCompareTask.setId(compareTaskId);
	updateCompareTask.setCompareBatchStatus(compareRelation.getCompareBatchStatus());

	compareTaskService.updateSelective(updateCompareTask);
}

/**
 * 
 * @param compareTaskId
 * @param compareBatchId
 * @return
 */
private CompareRelation getByCompareTaskIdAndCompareBatchId(Long compareTaskId, Long compareBatchId) {
	final CompareRelation query = new CompareRelation();
	query.setCompareTaskId(compareTaskId);
	query.setCompareBatchId(compareBatchId);
	final List<CompareRelation> list = compareRelationService.selectAll(query);
	return Tools.removeFirst(list);
}

/**
 * 
 * @param compareResultList
 * @return
 */
private Map<String, CompareResultHelper> getCompareResultMap(List<CompareResult> compareResultList) {
	final Map<String, CompareResultHelper> map = new ConcurrentHashMap<>(compareResultList.size() * 2);
	for (CompareResult compareResult : compareResultList) {
		final CompareResultHelper helper = new CompareResultHelper(compareResult);
		helper.setObjectMapper(objectMapper);
		map.put(compareResult.getCompareId(), helper);
	}
	return map;
}

/**
 * 
 * @param jobInfo
 * @return
 */
private Map<Long, DataSource> getDBDataSourceMap(final JobInfo jobInfo) {
	final Map<Long, DataSource> dbDataSourceMap = new TreeMap<>();
	final List<ResourceTable> resourceTableList = jobInfo.getResourceTableList();
	for (ResourceTable resourceTable : resourceTableList) {
		final Set<Long> dataSourceIDSet = getRelationDataSourceIDSet(resourceTable);
		dataSourceIDSet.removeAll(dbDataSourceMap.keySet());
		for (Long dataSourceID : dataSourceIDSet) {
			DataSource dbDataSource = dataSourceService.get(dataSourceID);
			dbDataSourceMap.put(dbDataSource.getId(), dbDataSource);
		}
	}
	return dbDataSourceMap;
}

/**
 * 创建Job ES连接
 * 
 * @param jobInfo
 * @return
 */
private RestHighLevelClient getESClient(final JobInfo jobInfo) {
	DataSource elasticSearchDataSource = jobInfo.getDataSourceList().stream()
			.filter(dataSources -> jobInfo.getDataSourceId().longValue() == dataSources.getId()).findFirst().get();
	final RestHighLevelClient elasticSearchClient = ElasticUtils.createElasticSearchClient(elasticSearchDataSource);
	return elasticSearchClient;
}

private Set<Long> getRelationDataSourceIDSet(final ResourceTable resourceTable) {
	if (resourceTable == null) {
		return new TreeSet<>();
	}
	final String[] split = StringUtils.split(resourceTable.getRelationDataSource(), ',');
	if (split == null) {
		return new TreeSet<>();
	}
	final Set<Long> idSet = new TreeSet<>();
	for (String dataSourceIDString : split) {
		dataSourceIDString = StringUtils.trimToEmpty(dataSourceIDString);
		final long dataSourceID = NumberUtils.toLong(dataSourceIDString, 0);
		if (dataSourceID > 0) {
			idSet.add(Long.valueOf(dataSourceID));
		}
	}
	return idSet;
}

// 按照dbNumber进行区分
private Map<String, List<DataSource>> dataSourceMap(Map<Long, DataSource> dbDataSourceMap) {
	Map<String, List<DataSource>> dataSourceMap = Maps.newConcurrentMap();
	List<DataSource> list = null;
	for (int i = 0; i < 10; i++) {
		list = Lists.newArrayList();
		for (DataSource dataSource : dbDataSourceMap.values()) {
			String url = dataSource.getDataSourceAddress();
			String dataBaseName = url.substring(url.lastIndexOf("/") + 1, url.lastIndexOf("?"));
			// 不是分库的也要添加进去
			if (!checkIsPartionDb(dataBaseName)) {
				list.add(dataSource);
			}
			// 数据源属于当前库
			if (checkIsNumber(i, dataBaseName)) {
				list.add(dataSource);
			}
		}
		if (!list.isEmpty()) {
			dataSourceMap.put(String.valueOf(i), list);
		}
	}
	return dataSourceMap;
}

// 校验是否分库
private boolean checkIsPartionDb(String str) {
	if (StringUtils.isNotBlank(str)) {
		String index = str.substring(str.lastIndexOf("_") + 1, str.length());
		if (StringUtils.isNumeric(index)) {
			return true;
		}
	}
	return false;
}

// 校验是不是当前dbNumber
private boolean checkIsNumber(int dbNumber, String str) {
	if (StringUtils.isNotBlank(str)) {
		String index = str.substring(str.lastIndexOf("_") + 1, str.length());
		if (StringUtils.isNumeric(index) && dbNumber == Integer.valueOf(index)) {
			return true;
		}
	}
	return false;
}

private void compare(final JobInfoHelper jobInfoHelper, final CompareResultHelper compareResultHelper)
		throws IOException {
	final CompareResult compareResult = compareResultHelper.getCompareResult();
	final ObjectNode dbData = compareResultHelper.getDBData();
	final ObjectNode esData = compareResultHelper.getESData();
	if (Tools.defaultLong(compareResult.getCompareDbNum()) < 1
			&& Tools.defaultLong(compareResult.getCompareEsNum()) < 1) {
		compareResult.setDbValue(objectMapper.writeValueAsString(compareResultHelper.getShowDBData()));
		compareResult.setEsValue(objectMapper.writeValueAsString(esData));
		compareResult.setCompareStatus(CompareResult.COMPARE_STATUS_EXCEPTION);
		compareResult.setDifferenceFieldNum(Long.valueOf(0L));
		compareResult.setDifferenceValue("{}");
		return;
	}

	final ObjectNode differenceValue = objectMapper.createObjectNode();
	long differenceFieldNum = 0;
	for (JobInfoItemHelper jobInfoItemHelper : jobInfoHelper.getJobInfoItemHelperList()) {
		if (!jobInfoItemHelper.isSubscribe()) {
			continue;
		}
		final String path = jobInfoItemHelper.getPath();
		final List<String> pathList = jobInfoItemHelper.getPathList();
		final JsonNode dbValue = getValue(dbData, pathList);
		final JsonNode esValue = getValue(esData, pathList);
		if (dbValue instanceof NullNode && esValue instanceof NullNode) {
			continue;
		}
		if (dbValue instanceof NullNode) {
			final ObjectNode objectNode = createFieldDifferent(jobInfoItemHelper, dbValue, esValue);
			differenceValue.set(path, objectNode);
			differenceFieldNum++;
			continue;
		}
		if (esValue instanceof NullNode) {
			final ObjectNode objectNode = createFieldDifferent(jobInfoItemHelper, dbValue, esValue);
			differenceValue.set(path, objectNode);
			differenceFieldNum++;
			continue;
		}

		if (isNumber(jobInfoItemHelper.getJobInfoItem())) {
			final double dbDouble = dbValue.asDouble(0D);
			final double esDouble = esValue.asDouble(0D);
			if (Double.doubleToLongBits(dbDouble) != Double.doubleToLongBits(esDouble)) {
				final ObjectNode objectNode = createFieldDifferent(jobInfoItemHelper, dbValue, esValue);
				differenceValue.set(path, objectNode);
				differenceFieldNum++;
			}
			continue;
		}
		if (!dbValue.asText().equals(esValue.asText())) {
			final ObjectNode objectNode = createFieldDifferent(jobInfoItemHelper, dbValue, esValue);
			differenceValue.set(path, objectNode);
			differenceFieldNum++;
		}
	}
	compareResult.setDifferenceFieldNum(Long.valueOf(differenceFieldNum));
	if (differenceFieldNum > 0) {
		compareResult.setDifferenceValue(objectMapper.writeValueAsString(differenceValue));
		compareResult.setCompareStatus(CompareResult.COMPARE_STATUS_EXCEPTION);
		compareResult.setDbValue(objectMapper.writeValueAsString(compareResultHelper.getShowDBData()));
		compareResult.setEsValue(objectMapper.writeValueAsString(esData));
	} else {
		compareResult.setDifferenceValue("{}");
		compareResult.setCompareStatus(CompareResult.COMPARE_STATUS_EQUAL);
		compareResult.setDbValue("{}");
		compareResult.setEsValue("{}");
	}
}

private JsonNode getValue(ObjectNode data, List<String> pathList) {
	JsonNode value = data;
	for (String path : pathList) {
		value = value.get(path);
		if (value == null) {
			return NullNode.getInstance();
		}
	}
	return value;
}

private ObjectNode createFieldDifferent(JobInfoItemHelper jobInfoItemHelper, JsonNode dbValue, JsonNode esValue) {
	final ObjectNode objectNode = objectMapper.createObjectNode();
	objectNode.set("db", dbValue);
	objectNode.set("es", esValue);

	final String orginTableName = jobInfoItemHelper.getJobInfoItem().getOrginTableName();
	final String orginFieldName = jobInfoItemHelper.getJobInfoItem().getOrginFieldName();
	objectNode.put("dbSrc", orginTableName + "." + orginFieldName);
	return objectNode;
}

private boolean isNumber(JobInfoItem jobInfoItem) {
	if ("double".equals(jobInfoItem.getDestFieldType())) {
		return true;
	}
	if ("decimal".equals(jobInfoItem.getOrginFieldType())) {
		return true;
	}
	return false;
}

}

weixin_43648977
关注
CountDownLatch实例二
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
10-24 738
import java.util.concurrent.CountDownLatch; public class CountDownlatchTest { public static void main(String[] args) throws InterruptedException { System.out.println("开始" + "," + Thread....
CountDownLatch实例一
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
10-24 869
import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; public class CountDownLatchExample { public static void main(String[] args) throws InterruptedException { ...
CountDownLatch的使用例子
u014190164的博客
08-09 735
CountDownLatch是主线程等待一堆子线程执行完之后，主线程在往下执行 例子： public List getRebotList(QueryRebotDto queryRebotDto) throws InfrastructureException{ List rebotList=new ArrayList(); try{ String ips=“http://10.17
阿里规范（一）关于CountDownLatch和ThreadLocalRandom的详解（带测试代码）
tangyuzhidao的博客
07-15 522
最近看了阿里代码规范，较之前相比加入了许多java的新特性。最新的文档有一定的门槛，比如有些是阿里dubbo特有的规范，我们也不用照搬，只需结合自身实际合理借鉴即可。给我印象最深的是集合和线程的规范，这两部分我写了不少的测试例子，给大家分享一下。（笔者推荐学习文档时配合阿里代码扫描插件，有eclipse版idea版。 阿里规范原文（1）：使用 CountDownLatch 进行异步转同步操作，每...
记一次CountDownLatch在SpringBoot中配合@Async使用
groggy_puppy的博客
08-06 5963
需求 项目使用springboot，有一个场景需要先从本地查询所有数据，然后再调用第三方接口填充其他字段，每次调用第三方接口都需要本地数据的字段作为查询条件。厂商提供的接口只能单个查询，所以只能遍历从本地查询的数据然后挨个调用接口，这样响应时间实在慢且效率太低。 那就想办法优化呗，第一想法肯定是启用多线程，让每一条从本地数据库查询的记录可以并行调用第三方接口。 首先新建一个线程任务类来调用第...
多线程并发辅助类CountDownLatch
qq_46641047的博客
07-13 164
多线程并发三大辅助类之CountDownLatch 什么是CountDownLatch CountDownLatch 含义：计数器 CountDownLatch类位于Java.util.concurrent.CountDownLatch包中 CountDownLatch使用 CountDownLatch对象创建 CountDownLatch countdownlatch = new CountDownLatch(int); 该对象的使用需要传入一个int类型的参数，此处int类型的参数主要
20.CountDownLatch闭锁
kfengqingyangk的博客
04-04 250
①Java5.0在java.util.concurrent包中提供了多种并发容器类来改进同步容器的性能。 ②CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 ③闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行： ---> 确保某个计算在其需要的所有资源都被初始化之后才继续执行；
CountDownLatch 实例
新博客地址：www.threeperson.com
03-29 141
多线程模拟记者发布会。每个记者提一个问题，且发布会要等每个记者问题准备好，会议才能开始，待所有记者发问完后，会议结束。 下面是模拟实例： [code="java"] package cn.com.ld.study.thread; /** * @filename: Reporter * @description: 记者 * @author lida...
Java CountDownLatch 实例
jxluoix的专栏
09-24 109
package com.java;   import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch;   abstract class AbstractSql { public abstract void execute(); }   class ...
CountDownLatch原理及实例
zhj100921的博客
09-29 246
1. 简介 CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程执行完后再执行。 CountDownLatch 在 JDK 1.5 被引入。 存在于 java.util.concurrent 包下。 例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行。 2. CountDownLatch 的原理 CountDown...
CountDownLatch和CyclicBarrier用法实例大全
06-08
在Java并发编程中，CountDownLatch和CyclicBarrier是两种非常重要的同步工具类，它们用于协调多个线程间的协作。这两个工具都是在`java.util.concurrent`包下，是Java并发库的重要组成部分。 **CountDownLatch** ...
Java多线程编程之CountDownLatch同步工具使用实例
09-03
程序创建了一个ExecutorService来管理线程池，然后创建了两个CountDownLatch实例：`cdOrder`和`cdAnswer`。`cdOrder`表示裁判发布的命令，计数器为1，意味着所有运动员必须等待裁判的命令才能开始。`cdAnswer`表示...
Java中CountDownLatch进行多线程同步详解及实例代码
08-31
Java中CountDownLatch进行多线程同步详解及实例代码 CountDownLatch是Java中的一种多线程同步辅助类，主要用来同步多个任务的执行。它允许一个或多个线程等待，直到一组正在其他线程中执行的操作完成。下面是对...
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
基于ssm的高校毕业生就业管理系统设计与实现.docx
最新发布
09-14
基于ssm的高校毕业生就业管理系统设计与实现.docx
CountDownLatch 具体实例，注意
08-16
CountDownLatch是一个同步辅助工具，用于实现一个或多个线程等待其他线程操作完成。它通过给定一个同步状态数量进行初始化，并在执行过程中通过调用countDown方法来阻塞await方法，直到同步状态数量为0，然后释放所有阻塞的线程，立即返回结果。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [CountDownLatch原理以及使用案例](https://blog.csdn.net/wr_java/article/details/115127491)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [JUC包：CountDownLatch源码+实例讲解](https://blog.csdn.net/Xin_101/article/details/129116170)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

weixin_43648977

原创

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值