msb-public
/
hippo4j
mirror of https://github.com/longtai-cn/hippo4j
1
0
Code Issues Projects Releases Wiki Activity

Merge pull request #289 from shining-stars-lk/develop

Browse Source 
Repair the conflict
1.3.1
小马哥 2 years ago committed by GitHub
parent f4bbf67bef 55e5b78026
commit 9e1281a50d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 75 additions and 28 deletions
Show Stats Download Patch File Download Diff File

33
hippo4j-adapter/hippo4j-adapter-base/src/main/java/cn/hippo4j/adapter/base/ThreadPoolAdapterRegisterAction.java
Unescape View File

@ -0,0 +1,33 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.hippo4j.adapter.base;
import java.util.Map;
/**
* Provide registration for each adaptation
*/
public interface ThreadPoolAdapterRegisterAction {
/**
* adapterRegister
* @param threadPoolAdapterMap
* @return
*/
void adapterRegister(Map<String, ThreadPoolAdapter> threadPoolAdapterMap);
}

2
hippo4j-adapter/hippo4j-adapter-base/src/main/java/cn/hippo4j/adapter/base/ThreadPoolAdapterScheduler.java
Unescape View File

@ -29,7 +29,7 @@ import java.util.concurrent.ScheduledThreadPoolExecutor;
@Slf4j
public class ThreadPoolAdapterScheduler {
private static final int TASK_INTERVAL_SECONDS = 2;
private static final int TASK_INTERVAL_SECONDS = 10;
private final ScheduledExecutorService scheduler;

18
hippo4j-adapter/hippo4j-adapter-hystrix/src/main/java/cn/hippo4j/adapter/hystrix/HystrixThreadPoolAdapter.java
Unescape View File

@ -17,10 +17,8 @@
package cn.hippo4j.adapter.hystrix;
import cn.hippo4j.adapter.base.ThreadPoolAdapter;
import cn.hippo4j.adapter.base.ThreadPoolAdapterScheduler;
import cn.hippo4j.adapter.base.ThreadPoolAdapterParameter;
import cn.hippo4j.adapter.base.ThreadPoolAdapterState;
import cn.hippo4j.adapter.base.*;
import cn.hippo4j.common.config.ApplicationContextHolder;
import cn.hippo4j.common.toolkit.CollectionUtil;
import com.google.common.collect.Maps;
import com.netflix.hystrix.HystrixThreadPool;
@ -79,7 +77,7 @@ public class HystrixThreadPoolAdapter implements ThreadPoolAdapter, ApplicationL
@Override
public List<ThreadPoolAdapterState> getThreadPoolStates() {
List<ThreadPoolAdapterState> threadPoolAdapterStates = new ArrayList<>();
HYSTRIX_CONSUME_EXECUTOR.forEach((kel, val) -> threadPoolAdapterStates.add(getThreadPoolState(String.valueOf(val))));
HYSTRIX_CONSUME_EXECUTOR.forEach((kel, val) -> threadPoolAdapterStates.add(getThreadPoolState(kel)));
return threadPoolAdapterStates;
}
@ -104,6 +102,16 @@ public class HystrixThreadPoolAdapter implements ThreadPoolAdapter, ApplicationL
@Override
public void onApplicationEvent(ApplicationStartedEvent event) {
// Periodically update the Hystrix thread pool
HystrixThreadPoolRefresh();
// Periodically refresh registration
ThreadPoolAdapterRegisterAction threadPoolAdapterRegisterAction = ApplicationContextHolder.getBean(ThreadPoolAdapterRegisterAction.class);
Map<String, ? extends HystrixThreadPoolAdapter> beansOfType = ApplicationContextHolder.getBeansOfType(this.getClass());
Map<String, ThreadPoolAdapter> map = Maps.newHashMap(beansOfType);
threadPoolAdapterRegisterAction.adapterRegister(map);
}
public void HystrixThreadPoolRefresh() {
ScheduledExecutorService scheduler = threadPoolAdapterScheduler.getScheduler();
int taskIntervalSeconds = threadPoolAdapterScheduler.getTaskIntervalSeconds();
HystrixThreadPoolRefreshTask hystrixThreadPoolRefreshTask = new HystrixThreadPoolRefreshTask(scheduler, taskIntervalSeconds);

50
hippo4j-spring-boot/hippo4j-spring-boot-starter/src/main/java/cn/hippo4j/springboot/starter/core/ThreadPoolAdapterRegister.java
Unescape View File

@ -17,10 +17,7 @@
package cn.hippo4j.springboot.starter.core;
import cn.hippo4j.adapter.base.ThreadPoolAdapter;
import cn.hippo4j.adapter.base.ThreadPoolAdapterCacheConfig;
import cn.hippo4j.adapter.base.ThreadPoolAdapterScheduler;
import cn.hippo4j.adapter.base.ThreadPoolAdapterState;
import cn.hippo4j.adapter.base.*;
import cn.hippo4j.common.config.ApplicationContextHolder;
import cn.hippo4j.common.toolkit.CollectionUtil;
import cn.hippo4j.common.web.base.Result;
@ -51,8 +48,7 @@ import static cn.hippo4j.common.constant.Constants.REGISTER_ADAPTER_PATH;
*/
@Slf4j
@AllArgsConstructor
@RequiredArgsConstructor
public class ThreadPoolAdapterRegister implements ApplicationRunner {
public class ThreadPoolAdapterRegister implements ApplicationRunner, ThreadPoolAdapterRegisterAction {
private final HttpAgent httpAgent;
@ -64,23 +60,18 @@ public class ThreadPoolAdapterRegister implements ApplicationRunner {
private final ThreadPoolAdapterScheduler threadPoolAdapterScheduler;
private List<ThreadPoolAdapterCacheConfig> cacheConfigList = Lists.newArrayList();
@Override
public void run(ApplicationArguments args) throws Exception {
ScheduledExecutorService scheduler = threadPoolAdapterScheduler.getScheduler();
int taskIntervalSeconds = threadPoolAdapterScheduler.getTaskIntervalSeconds();
ThreadPoolAdapterRegisterTask threadPoolAdapterRegisterTask = new ThreadPoolAdapterRegisterTask(scheduler, taskIntervalSeconds);
scheduler.schedule(threadPoolAdapterRegisterTask, threadPoolAdapterScheduler.getTaskIntervalSeconds(), TimeUnit.SECONDS);
register();
}
public List<ThreadPoolAdapterCacheConfig> getThreadPoolAdapterCacheConfigs() {
Map<String, ThreadPoolAdapter> threadPoolAdapterMap = ApplicationContextHolder.getBeansOfType(ThreadPoolAdapter.class);
public List<ThreadPoolAdapterCacheConfig> getThreadPoolAdapterCacheConfigs(Map<String, ThreadPoolAdapter> threadPoolAdapterMap) {
List<ThreadPoolAdapterCacheConfig> cacheConfigList = Lists.newArrayList();
threadPoolAdapterMap.forEach((key, val) -> {
for (Map.Entry<String, ThreadPoolAdapter> threadPoolAdapterEntry : threadPoolAdapterMap.entrySet()) {
ThreadPoolAdapter val = threadPoolAdapterEntry.getValue();
List<ThreadPoolAdapterState> threadPoolStates = val.getThreadPoolStates();
if (CollectionUtil.isEmpty(threadPoolStates)) {
return;
if (CollectionUtil.isEmpty(threadPoolStates) || threadPoolStates.size() == 0) {
continue;
}
ThreadPoolAdapterCacheConfig cacheConfig = new ThreadPoolAdapterCacheConfig();
cacheConfig.setMark(val.mark());
@ -91,12 +82,12 @@ public class ThreadPoolAdapterRegister implements ApplicationRunner {
cacheConfig.setClientAddress(clientAddress);
cacheConfig.setThreadPoolAdapterStates(threadPoolStates);
cacheConfigList.add(cacheConfig);
});
}
return cacheConfigList;
}
public void doRegister(List<ThreadPoolAdapterCacheConfig> cacheConfigList) {
if (CollectionUtil.isNotEmpty(cacheConfigList)) {
if (CollectionUtil.isNotEmpty(cacheConfigList) && cacheConfigList.size() > 0) {
try {
Result result = httpAgent.httpPost(REGISTER_ADAPTER_PATH, cacheConfigList);
if (!result.isSuccess()) {
@ -109,25 +100,40 @@ public class ThreadPoolAdapterRegister implements ApplicationRunner {
}
public void register() {
List<ThreadPoolAdapterCacheConfig> threadPoolAdapterCacheConfigs = getThreadPoolAdapterCacheConfigs();
Map<String, ThreadPoolAdapter> threadPoolAdapterMap = ApplicationContextHolder.getBeansOfType(ThreadPoolAdapter.class);
List<ThreadPoolAdapterCacheConfig> threadPoolAdapterCacheConfigs = getThreadPoolAdapterCacheConfigs(threadPoolAdapterMap);
doRegister(threadPoolAdapterCacheConfigs);
}
@Override
public void adapterRegister(Map<String, ThreadPoolAdapter> threadPoolAdapterMap) {
ScheduledExecutorService scheduler = threadPoolAdapterScheduler.getScheduler();
int taskIntervalSeconds = threadPoolAdapterScheduler.getTaskIntervalSeconds();
ThreadPoolAdapterRegisterTask threadPoolAdapterRegisterTask = new ThreadPoolAdapterRegisterTask(scheduler, taskIntervalSeconds, threadPoolAdapterMap);
scheduler.schedule(threadPoolAdapterRegisterTask, threadPoolAdapterScheduler.getTaskIntervalSeconds(), TimeUnit.SECONDS);
}
class ThreadPoolAdapterRegisterTask implements Runnable {
private ScheduledExecutorService scheduler;
private int taskIntervalSeconds;
public ThreadPoolAdapterRegisterTask(ScheduledExecutorService scheduler, int taskIntervalSeconds) {
Map<String, ThreadPoolAdapter> threadPoolAdapterMap;
private List<ThreadPoolAdapterCacheConfig> cacheConfigList = Lists.newArrayList();
public ThreadPoolAdapterRegisterTask(ScheduledExecutorService scheduler, int taskIntervalSeconds,
Map<String, ThreadPoolAdapter> threadPoolAdapterMap) {
this.scheduler = scheduler;
this.taskIntervalSeconds = taskIntervalSeconds;
this.threadPoolAdapterMap = threadPoolAdapterMap;
}
@Override
public void run() {
try {
List<ThreadPoolAdapterCacheConfig> newThreadPoolAdapterCacheConfigs = getThreadPoolAdapterCacheConfigs();
List<ThreadPoolAdapterCacheConfig> newThreadPoolAdapterCacheConfigs = getThreadPoolAdapterCacheConfigs(threadPoolAdapterMap);
boolean registerFlag = compareThreadPoolAdapterCacheConfigs(newThreadPoolAdapterCacheConfigs, cacheConfigList);
cacheConfigList = newThreadPoolAdapterCacheConfigs;
if (registerFlag) {

Write Preview
Loading…
Cancel
Save