2021年 – 第13页

Android 2月 11,2021

public class AutoScrollTextView extends TextView implements OnClickListener {
public final static String TAG = AutoScrollTextView.class.getSimpleName();
private int runNum = 1;// 滚动次数
private float textLength = 0f;// 文本长度
private float viewWidth = 0f;
private float step = 0f;// 文字的横坐标
private float y = 0f;// 文字的纵坐标
private float temp_view_plus_text_length = 0.0f;// 用于计算的临时变量
private float temp_view_plus_two_text_length = 0.0f;// 用于计算的临时变量
public boolean isStarting = false;// 是否开始滚动
private Paint paint = null;// 绘图样式
private Paint paint1 = null;// 绘图样式
private String text = “”;// 文本内容
private boolean isFade = true;// 是否加影子
private float layout_width = 168f;

public float getLayout_width() {
    return layout_width;
}

public void setLayout_width(float layoutWidth) {
    layout_width = layoutWidth;
}

public boolean isFade() {
    return isFade;
}

public void setFade(boolean isFade) {
    this.isFade = isFade;
}

public AutoScrollTextView(Context context) {
    super(context);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    initView();
}

/** */
/**
 * 初始化控件
 */
private void initView() {
    setOnClickListener(this);
}

/** */
/**
 * 文本初始化，每次更改文本内容或者文本效果等之后都需要重新初始化一下
 */
public void init(WindowManager windowManager) {
    paint = getPaint();
    paint1 = new Paint();
    paint1.setColor(Color.WHITE);
    paint1.setTextSize(getTextSize());
    text = getText().toString();
    textLength = paint.measureText(text);
    viewWidth = layout_width * LogoActivity.screenHeight / 960;
    if (textLength > viewWidth * 2) {
        isStarting = true;
    }
    Log.e("    textLength      ", textLength + "         " + viewWidth);
    if (viewWidth == 0) {
        if (windowManager != null) {
            Display display = windowManager.getDefaultDisplay();
            viewWidth = display.getWidth();
        }
    }
    temp_view_plus_text_length = viewWidth + textLength;
    temp_view_plus_two_text_length = viewWidth + textLength * 2;
    step = temp_view_plus_text_length;
    y = getTextSize() + getPaddingTop();
}

@Override
public Parcelable onSaveInstanceState() {
    Parcelable superState = super.onSaveInstanceState();
    SavedState ss = new SavedState(superState);

    ss.step = step;
    ss.isStarting = isStarting;

    return ss;

}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (!(state instanceof SavedState)) {
        super.onRestoreInstanceState(state);
        return;
    }
    SavedState ss = (SavedState) state;
    super.onRestoreInstanceState(ss.getSuperState());

    step = ss.step;
    isStarting = ss.isStarting;

}

public static class SavedState extends BaseSavedState {
    public boolean isStarting = false;
    public float step = 0.0f;

    SavedState(Parcelable superState) {
        super(superState);
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        super.writeToParcel(out, flags);
        out.writeBooleanArray(new boolean[] { isStarting });
        out.writeFloat(step);
    }

    public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {

        public SavedState[] newArray(int size) {
            return new SavedState[size];
        }

        @Override
        public SavedState createFromParcel(Parcel in) {
            return new SavedState(in);
        }
    };

    private SavedState(Parcel in) {
        super(in);
        boolean[] b = null;
        in.readBooleanArray(b);
        if (b != null && b.length > 0)
            isStarting = b[0];
        step = in.readFloat();
    }
}

/** */
/**
 * 开始滚动
 */
public void startScroll() {
    isStarting = true;
    invalidate();
}

/** */
/**
 * 停止滚动
 */
public void stopScroll() {
    isStarting = false;
    runNum = 1;
    invalidate();

}

@Override
public void onDraw(Canvas canvas) {
    if (isFade)canvas.drawText(text, temp_view_plus_text_length - step, y, paint1);
    canvas.drawText(text, temp_view_plus_text_length - step, y - 1, paint);
    if (!isStarting) {
        return;
    }
    step += 1;
    if (step > temp_view_plus_two_text_length) {
        step = textLength - viewWidth;
        runNum--;

    }
    if (runNum == 0 && step == temp_view_plus_text_length) {
        isStarting = false;
    }
    invalidate();

}

@Override
public void onClick(View v) {

// if (isStarting)
// stopScroll();
// else
// startScroll();

}

作者 east

Android 2月 11,2021

Android游戏加载资源通用类

开发游戏，通常需要在Assets中加载图片和多语言包，下面有个封装类。

/**
 * 图片加载类.
 * 
 * @author 凉
 * 
 */
public class Assets {
	private static Map<String, Map<String, String>> drawables = new HashMap<String, Map<String, String>>();

	private static Map<String, String> raws = new HashMap<String, String>();

	/**
	 * 如果是中文,则从drawable-zh目录加载图片.如果没有,在从drawable里面加载.
	 * 
	 * @param name
	 * @return
	 */
	public static String get(String name) {
		String result = null;
		if (isLunarSetting()) {
			Map map = (Map) drawables.get("drawable-zh");
			if (map != null) {
				String str3 = get(map, name);
				MyLog.d("", ">>>>>>>>>>>path>>>cn>>drawables:" + str3
						+ "   name:" + name);
				if (str3 != null) {
					result = str3;
				} else {
					String str4 = get((Map) drawables.get("drawable"), name);
					MyLog.d("", ">>>>>>>>>>>path>>>en>1>drawables:" + str4
							+ "   name:" + name);
					if (str4 != null) {
						result = str4;
					}
				}
			} else {
				String str2 = get((Map) drawables.get("drawable"), name);
				MyLog.d("", ">>>>>>>>>>>path>>>en>2>drawables:" + str2
						+ "   name:" + name);
				if (str2 != null) {
					result = str2;
				}
			}
		} else {
			String str1 = get((Map) drawables.get("drawable"), name);
			MyLog.d("", ">>>>>>>>>>>path>>>en>3>drawables:" + str1 + "   name:"
					+ name);
			if (str1 != null) {
				result = str1;
			}
		}
		return result;
	}

	private static String get(Map<String, String> map, String name) {
		String str = null;
		if (map.get(name + ".png") != null)
			str = (String) map.get(name + ".png");
		else {
			if (map.get(name + ".jpg") != null) {
				str = (String) map.get(name + ".jpg");
			}
		}
		return str;
	}

	private static String getLanguageEnv() {
		Locale local = Locale.getDefault();
		String language = local.getLanguage();
		String country = local.getCountry().toLowerCase();
		if ("zh".equals(language)) {
			if ("cn".equals(country))
				language = "zh-CN";
			else if ("tw".equals(country)) {
				language = "zh-TW";
			}
		} else if ("pt".equals(language)) {
			if ("br".equals(country)) {
				language = "pt-BR";
			} else if ("pt".equals(country)) {
				language = "pt-PT";
			}
		}
		return language;
	}

	/**
	 * 获取.plist资源.
	 * 
	 * @param name
	 * @return
	 */
	public static String getRaw(String name) {
		return (String) raws.get(name + ".plist");
	}

	/**
	 * 把文件夹res下面的drawable和raw下面的文件路径全部缓存起来.
	 * 
	 * @param context
	 * @throws IOException
	 */
	public static void init(Context context) throws IOException {
		String[] arraystr = context.getAssets().list("res");
		int i = arraystr.length;
		for (int j = 0; j < i; j++) {
			String str1 = arraystr[j];
			String[] strings;
			HashMap drawable;
			if (str1.startsWith("drawable")) {
				strings = context.getAssets().list("res/" + str1);
				drawable = new HashMap();
				int n = strings.length;
				for (int i1 = 0; i1 < n; i1++) {
					String str3 = strings[i1];
					drawable.put(str3, "res/" + str1 + "/" + str3);
				}
				drawables.put(str1, drawable);
			} else if (str1.equals("raw")) {
				String[] lists = context.getAssets().list("res/" + str1);
				for (String str2 : lists)
					raws.put(str2, "res/" + str1 + "/" + str2);
			}
		}
	}

	/**
	 * 是否是中文.
	 * 
	 * @return
	 */
	public static boolean isLunarSetting() {
		String str = getLanguageEnv();
		return ((str != null) && ((str.trim().equals("zh-CN")) || (str.trim()
				.equals("zh-TW"))));
	}
}

作者 east

运维 2月 8,2021

shell监控日志关键字，并杀死有故障进程重启

在实际开发当中，会遇到很多程序运行一段时间出现故障，例如flume没有采集日志，写hbase的程序出现”Too many open files”或”session Time out”。除了把代码写健壮性，尽量能做到7*24小时零故障保障，还可以通过crontab来配置定时检测的脚本，分析程序的日志，根据关键来产生预警，或者来进行kill掉进程进行重启。

#bin/sh
is_equal(){
  if [ $1 eq '1' ]
  then
    echo $pid
    kill -9 $pid
    echo $?
  else exit
fi
//$7是gawk分割netstat -tunpl | grep 8083产生字符串的位置
my_pid=`netstat -tunpl | grep 8083 | gawk '{print $7}'`
cur_statu=`cat /app/my.log | tail -n 1 | grep 'Too many open files '|gawk -F 'Too many open files' '{print 1}'`
echo $cur_statu
is_equal $cur_statu $my_pid
sleep 5
nohup java -jar my.jar >/app/my.log 2>&1 &
echo 重启程序

作者 east

shardingsphere 2月 6,2021

shardingsphere4.0+Springboot+Mybatis+druid动态多数据源

首先Springboot+Mybatis+druid动态多数据源的配置是这样的

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@MapperScan(basePackages = "com.xxx.xxx.mapper")
@Import({DynamicDataSourceConfig.class})
public class BootApplication {

	public static void main(String[] args) {
		TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
		SpringApplication.run(BootApplication.class, args);
	}

}

application.pro的关键配置如下：

spring:

datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 配置监控服务器：http://ip:端口/druid/index.html
stat-view-servlet:
login-username: admin
login-password: kisen@123
reset-enable: false
url-pattern: /druid/*

  master: # 主数据源
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://167.1.6.163:53306/master?serverTimezone=Asia/Shanghai&useSSL=false&allowMultiQueries=true

  slave: # 从数据源
    #        driverClassName: org.postgresql.Driver
    #        username: postgres
    #        password: postgres
    #        url: jdbc:postgresql://192.168.30.22:5432/slave_db
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://157.1.6.134:53

动态切换的配置文件如下：


import java.lang.annotation.*;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String name() default "";
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(DataSource)")
    public void dataSourcePointCut() {

    }


    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();


        DataSource dataSource = method.getAnnotation(DataSource.class);
        if(dataSource == null){
            DynamicDataSource.setDataSource("master");
        }else {
            System.out.println("dataSource.name()===="+dataSource.name());
            DynamicDataSource.setDataSource(dataSource.name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource  extends AbstractRoutingDataSource {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    private static Logger log = LoggerFactory.getLogger(DynamicDataSource.class);

    @Override
    protected Object determineCurrentLookupKey() {
     //   log.info("getDataSource()===================="+getDataSource());
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
        log.info("切换到{"+dataSource+"}数据源");
        log.info("切换到{"+dataSource+"}数据源");
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

下面是最关键的地方，要对普通的druid多数据源动态切换做如下修改


import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DynamicDataSourceConfig {


    @Bean(name = "master")
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource  masterDataSource(){
        return DruidDataSourceBuilder.create().build();
    }



    @Bean(name = "slave")
    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource  anjianSlaveDataSource(){
        return DruidDataSourceBuilder.create().build();
    }

@Bean(name = "sharding")
public DataSource getShardingDataSource() throws SQLException {
		ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
 
		//  分库分表逻辑，在这里不做代码展示
 
		return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), shardingRuleConfig,new ConcurrentHashMap(), properties);
	}

 public  Map<String, DataSource> createDataSourceMap() {
	   Map<String, DataSource> dataSourceMap = new HashMap<String, DataSource>(4);
	   // 配置第一个数据源
       DruidDataSource data1 = new DruidDataSource();
       data1.setDriverClassName("数据源驱动");
       data1.setUrl("数据库链接1");
       data1.setUsername("用户名");
       data1.setPassword("密码");
       dataSourceMap.put("data1 ", data1 );
 
       // 配置第二个数据源
       DruidDataSource data2 = new DruidDataSource();
       data2.setDriverClassName("数据源驱动");
       data2.setUrl("数据库链接2");
       data2.setUsername("用户名");
       data2.setPassword("密码");
       dataSourceMap.put("data2 ", data2 );
 
       // 配置第三个数据源
       DruidDataSource data3 = new DruidDataSource();
       data3.setDriverClassName("数据源驱动");
       data3.setUrl("数据库链接3");
       data3.setUsername("用户名");
       data3.setPassword("密码");
       dataSourceMap.put("data3", data3);
       
       // 配置第四个数据源
       DruidDataSource data4 = new DruidDataSource();
       data4.setDriverClassName("数据源驱动");
       data4.setUrl("j数据库链接4");
       data4.setUsername("用户名");
       data4.setPassword("密码");
       dataSourceMap.put("data4", data4);
       
       return dataSourceMap;
   }
 
}



    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource());
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap();
        dsMap.put("master", masterDataSource());
        dsMap.put("slave-anjian", anjianSlaveDataSource());

        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }

    /**
     * 配置@Transactional注解事物
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }

}

作者 east

Elasticsearch 1月 31,2021

ES的内存xms和xmx设置不一致导致启动失败

问题背景与现象

ES启动失败：

1. 页面显示ES实例启动失败，查看详情是Xms和Xmx大小不一致；

ES的内存xms和xmx设置不一致导致启动失败

2. 查看ES后台日志，报错如下，初始化内存和最大内存不一致，导致启动失败

/var/log/Bigdata/elasticsearch/esnode1/elasticsearch_cluster.log

2018-12-11T17:21:49,670][INFO ][o.e.b.BootstrapChecks    ] [EsNode1] bound or publishing to a non-loopback address, enforcing bootstrap checks
[2018-12-11T17:21:49,673][ERROR][o.e.b.Bootstrap          ] [EsNode1] node validation exception
[1] bootstrap checks failed
[1]: initial heap size [536870912] not equal to maximum heap size [1073741824]; this can cause resize pauses and prevents mlockall from locking the entire heap
[2018-12-11T17:21:49,677][INFO ][o.e.n.Node               ] [EsNode1] stopping ...
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] stopped
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] closing ...
[2018-12-11T17:21:49,721][INFO ][o.e.n.Node               ] [EsNode1] closed

原因分析

如果JVM以不等的初始(Xms)和最大(Xmx)堆(heap)大小启动，则可能会在系统使用期间调整JVM堆的大小，因此可能会暂停。为了避免这些调整大小的停顿，需要使初始(Xms)堆(heap)大小等于最大Xms堆(heap)大小启动JVM。另外，启用了bootstrap.memory_lock，JVM将在启动时锁定堆(heap)的初始(Xms)大小。如果初始堆大小不等于最大堆大小，在重新调整大小之后，将不会将所有JVM堆锁定在内存中。

因此是ES的内核限制，要求ES的启动参数的初始(Xms)和最大(Xmx)内存相等。

作者 east

Elasticsearch 1月 31,2021

Elasticsearch(ES)运维常用命令

集群检查常用命令

1. 查询集群状态命令：

curl -XGET "http://ip:port/_cluster/health?pretty"

2. 查询Es全局状态：

curl -XGET "http://ip:port/_cluster/stats?pretty"

3. 查询集群设置

curl -XGET "http://ip:port/_cluster/settings?pretty"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

5. 查看集群别名组

curl -XGET "http://ip:port/_cat/aliases"

6.查看当前集群索引分片信息

curl -XGET "http://ip:port/_cat/shards?v"   注：查看某一个索引可用shards/索引名?v

7.查看集群实例存储详细信息

curl -XGET "http://ip:port/_cat/allocation?v"

8.查看当前集群的所有实例

curl -XGET "http://ip:port/_cat/nodes?v"

9.查看某索引分片转移进度

curl -XGET "http://ip:port/_cat/recovery/索引名?v"

10.查看当前集群等待任务

curl -XGET "http://ip:port/_cat/pending_tasks?v"

11.查看集群写入线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/bulk?v"

12.查看集群查询线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/search?v"

13.查看分片未分配的原因

curl -XGET "http://127.0.0.1:24100/_cat/shards?v&h=index,shard,prirep,state,node,unassigned.reason" | grep UNASSIGNED

集群设置常用命令

1. 设置集群分片恢复参数

curl -XPUT   "http://ip:httpport/_cluster/settings"  -H  'Content-Type: application/json' -d' 
{ 
"transient": { 
   "cluster.routing.allocation.node_initial_primaries_recoveries":60,
   "cluster.routing.allocation.node_concurrent_recoveries":30,
   "cluster.routing.allocation.cluster_concurrent_rebalance":30
   } 
}'

2. 根据实例名称使EsNodeX实例下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
        "cluster.routing.allocation.exclude._name": "EsNode2@ip" 
     } 
}'

3. 根据ip使ES数据节点下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
          "cluster.routing.allocation.exclude._ip": "ip1,ip2,ip3" 
     } 
}'

4. 设置分片恢复过程中的最大带宽速度：

curl -XPUT "http://127.0.0.1:24100/_cluster/settings" -H 'Content-Type: application/json' -d
'{
 "transient":{
     "indices.recovery.max_bytes_per_sec":"500mb"
  }
}'

5. 重新分片为空的主分片

 curl -XPOST  "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
                "allocate_empty_primary": {		
                                      "index": "indexname",			
                                      "shard": 2,
                                      "node": "EsNode1@81.20.5.24",
                                      "accept_data_loss":true
                                           }
               }]
}'

6. 重新分配主分片，会尝试将过期副本分片分片为主。

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
               "allocate_stale_primary": {
                                        "index": "index1",
                                        "shard": 2,
			                "node": "EsNode1@189.39.172.103",
                                        "accept_data_loss":true
                                          }
               }]
}'

7. 清理ES所有缓存

curl -XPOST "http://ip:port/_cache/clear"

8.关闭分片自动平衡

curl -XPUT
 "http://ip:port/_cluster/settings" -H 'Content-Type:application/json' -d '
{
   "transient":{   "cluster.routing.rebalance.enable":"none" }
}'

9.手动刷新未分配的分片

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?retry_failed=true"

索引查看常用命令

1. 查询索引mapping和settings

curl -XGET_{--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name?pretty'}

2. 查询索引settings

curl -XGET--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name/_settings?pretty'

3.查看分片未分配详细命令

curl -XGET "http://127.0.0.1:24100/_cluster/allocation/explain?pretty" -H 'Content-Type:application/json' -d '
{"index": "indexname","shard": 17,"primary": true}'

4.修改索引只读字段属性为null，放开写入

curl -XPUT  "http://127.0.0.1:24100/*/_settings" -H 'Content-Type: application/json' -d '{"index.blocks.read_only_allow_delete": null}'

索引设置常用命令

1.关闭索引

curl -XPOST 'http://ip:port/my_index/_close?pretty'

2.打开索引

curl -XPOST 'http://ip:port/my_index/_open?pretty'

3.修改索引刷新时间：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"refresh_interval" : "60s"}'

4.修改translog文件保留时长，默认为12小时

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.translog.retention.age" : "30m"}'

5.设置索引副本：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"number_of_replicas" : 1}'

6.执行refresh，将内存数据刷新到磁盘缓存

curl -XPOST 'http://ip:port/myindex/_refresh'

7.执行flush，将磁盘缓存刷新到文件系统

curl -XPOST 'https://ip:port/myindex/_flush'

8.执行synced flush，生成syncid

curl -XPOST  'http://ip:port/_flush/synced'

9. 强制执行段合并

curl -XPOST 'http://ip:httpport/myindex/_forcemerge?only_expunge_deletes=false&max_num_segments=1&flush=true&pretty'

10.设置索引在每个esnode上的分片个数

curl -XPUT 'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.routing.allocation.total_shards_per_node" : "2"}'

11. 配置控制段合并的refresh、merge线程数等

curl -XPUT  "http://ip:port/my_index/_settings?pretty" -H 'Content-Type: application/json' -d'
{"refresh_interval": "60s",
 "merge":{"scheduler"：{"max_merge_count" : "100",
                        "max_thread_count" : "1"},
          "policy":{"segments_per_tier" : "100",
                    "floor_segment" : "1m",
                    "max_merged_segment" : "2g"}
          }
}'

12.设置索引的刷新时间和translog配置参数

注意：设置translog参数，必须先关闭索引，设置完成后再打开

*代表设置所有索引，如果要设置具体某个索引，可以将*替换为具体的索引名称

curl -XPUT "http://ip:httpport/*/_settings" -H 'Content-Type: application/json' -d'
{ "index": 
          { "refresh_interval" : "60s",
            "translog": 
                      { "flush_threshold_size": "1GB", "sync_interval": "120s", "durability": "async" 
                      } 
          } 
}'

13.限制每个索引在每个实例上的分片个数

curl -XPUT  'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type:application/json' -d '{"index.routing.allocation.total_shards_per_node":"2"}'

实例检查常用命令

1.查看实例安装插件

curl -XGET "http://ip:port/_cat/aliases"

2.查询指定ES实例的jvm参数：

curl -XGET 'http://ip:port/_nodes/EsNode1*/stats/jvm?pretty'
curl -XGET 'http://ip:port/_nodes/EsNode1@12.40.16.156/stats/jvm?pretty'

作者 east

Elasticsearch 1月 31,2021

Elasticsearch规划及性能规格

影响因子分析

Elasticsearch组件的索引和查询性能主要受到物理资源（内存、磁盘、CPU、网络）和逻辑资源（数据类型、数据长度、分词类别）的影响。

物理资源

影响因子如：

内存：内存大小会影响到写入数据的速度、缓存的多少。
磁盘：磁盘的性能影响到索引数据写入磁盘的速度。
CPU：CPU的性能影响到分词的速度、处理倒排索引的速度等。
网络：影响到分布式索引和查询消息处理的速度。

逻辑资源

影响因子如：

数据类型：字符串、整型、浮点型，不同的数据类型对资源的消耗程度不同。
数据长度：字段的大小对资源的消耗程度不同。
分词类别：采用不同的分词器对资源的消耗程度不同。
shard个数划分：根据数据量的不同应当对index赋予不同的shard个数。

物理资源规划

频繁的请求下，Elasticsearch对内存、CPU、网络与磁盘的性能有较高的要求，一般情况下，建议Elasticsearch独占这些物理资源，尽量不与其他耗资源的组件合布。

磁盘使用必须使用SAS盘，不建议使用SATA盘进行存储。

内存配置

FusionInsight Elasticsearch单节点（node）默认分配的HeapSize为4GB，若机器内存的50%>实例数*31G，设置为31G，否则设置为机器内存的50%/实例数。资源允许的情况下，单个实例可以分配的最大HeapSize不要超过31GB。

另外，需要留下一半的物理内存作为Lucene缓存使用。如果不按照此建议设置，将会影响索引与查询的性能。

示例

如果系统为128GB物理内存，那么建议留下64GB预留给Lucene缓存，剩下的64GB可以分配2个Elasticsearch节点（nodes）。每个节点分配31GB内存。
如果系统为256GB物理内存，安装上面的计算实际上我们可以设置4个EsNode但是不建议安装4个。说明： 256G及以上内存的机器只建议安装3个EsNode实例。虽然内存满足要求，但是由于受CPU核数的限制集群性能不会有太大提升。多余的内存Lucene也会全部利用了。

磁盘挂载

Elasticsearch单索引数据目前可以较优支持到TB级别，数据量庞大，建议Elasticsearch按照实例（nodes）进行单独挂盘。

示例

用户某个物理机上分配了两个Elasticsearch nodes，分别是EsNode1和EsNode2，一个实例对应写一个固定磁盘。需要为这两个实例挂载两个磁盘，挂载目录分别为“/srv/BigData/elasticsearch/esnode1/”和“/srv/BigData/elasticsearch/esnode2/”。

说明：

磁盘类型不同，性能也相差巨大。如：SSD读写速度大约是SAS盘的50倍，而SAS盘读写速度可以达到SATA盘的2倍以上。
Elasticsearch的总实例数在500以上时，EsMaster必须使用SSD盘，且EsMaster可使用的CPU资源要大于等于32核。

shard个数规划

一个index可以被分为多个shards，从而分布到不同的物理机上。Shard的划分结果也会影响索引和查询速度。

每个分片都可以处理数据写入和查询请求，在设置索引分片数时，可从以下几个方面考虑：

每个shard包含的数据条数越多，查询性能会降低（建议1亿条左右，最多建议不超过4亿）。
建议单个分片保存的数据量在20GB左右，最大不超过30GB。
根据索引预计承载的最大数据容量和单个分片容量确定主分片个数。一般来说，预计存储的数据量越大，应当分配的shard越多，分布式查询的优势越明显。如果确认某个index的数据量非常少（如一年不到1GB），那么过多的分配shard，反而可能不如单shard的性能好
为了提升数据可靠性，合理设置副本分片个数，至少设置为1，如果集群的存储空间足够，推荐设置为2。
每个node可以支撑的shards个数是有限的，node是物理资源分配的对象，随着shards中数据的增大，shards中的数据在查询时被不断加载到内存，达到一定量时，将会把HeapSize耗尽，导致频繁GC，系统将不能正常工作。推荐1GB内存管理15个shard，以一个Elasticsearch实例内存最大31G为例，单实例管理的shard数保持在500以内。
当Elasticsearch集群实例数大于500时，请确保Elasticsearch集群的总shard数小于等于50000个。过多的shard数会导致EsMaster压力过大，Elasticsearch集群不稳定。

shard个数规划

一个index可以被分为多个shards，从而分布到不同的物理机上。Shard的划分结果也会影响索引和查询速度。

每个分片都可以处理数据写入和查询请求，在设置索引分片数时，可从以下几个方面考虑：

每个shard包含的数据条数越多，查询性能会降低（建议1亿条左右，最多建议不超过4亿）。
建议单个分片保存的数据量在20GB左右，最大不超过30GB。
根据索引预计承载的最大数据容量和单个分片容量确定主分片个数。一般来说，预计存储的数据量越大，应当分配的shard越多，分布式查询的优势越明显。如果确认某个index的数据量非常少（如一年不到1GB），那么过多的分配shard，反而可能不如单shard的性能好
为了提升数据可靠性，合理设置副本分片个数，至少设置为1，如果集群的存储空间足够，推荐设置为2。
每个node可以支撑的shards个数是有限的，node是物理资源分配的对象，随着shards中数据的增大，shards中的数据在查询时被不断加载到内存，达到一定量时，将会把HeapSize耗尽，导致频繁GC，系统将不能正常工作。推荐1GB内存管理15个shard，以一个Elasticsearch实例内存最大31G为例，单实例管理的shard数保持在500以内。
当Elasticsearch集群实例数大于500时，请确保Elasticsearch集群的总shard数小于等于50000个。过多的shard数会导致EsMaster压力过大，Elasticsearch集群不稳定。

作者 east

Android, bug清单 1月 5,2021

Android解决Only the original thread that created a view hierarchy can touch its views问题

 
比如在电话的应用程序中，有一个线程是RingTone，如果这个非UI线程中直接操作UI线程，会抛出android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views: 
   1. Why
       为什么会有这种异常产生呢？
       
      当每个应用程序apk第一次启动时，Android会同时启动一个对应的主线程（Main Thread），
      主线程负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，
      并把相关的事件分发到对应的组件进行处理，所以主线程通常又被叫做UI线程。


      但是在开发Android应用时必须遵守单线程模型的原则： 
      Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行，如果在非UI线程中直接操作UI线程，
      会抛出android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that 
      created a view hierarchy can touch its views，这与普通的java程序不同。


       由于UI线程负责事件的监听和绘图，因此，必须保证UI线程能够随时响应用户的需求，
       UI线程里的操作应该向中断事件那样短小，费时的操作（如网络连接）需要另开线程，
       否则，如果UI线程超过5s没有响应用户请求，会弹出对话框提醒用户终止应用程序（ANP）。


       如果在新开的线程中需要对UI进行设定，就可能违反单线程模型，
       因此android采用一种的Message Queue机制保证线程间通信。


       Message Queue是一个消息队列，用来存放通过Handler发送的消息。
       Android在第一启动程序时会默认会为UI thread创建一个关联的消息队列，
      可以通过Looper.myQueue()得到当前线程的消息队列，用来管理程序的一些上层组件，
      activities，broadcast receivers 等，你可以在自己的子线程中创建Handler与UI thread通讯。


      Handler会向message queue通过两种方法发送消息：send或post。
      这两种消息都会插在message queue队尾并按先进先出执行，
      但通过这两种方法发送的消息执行的方式略有不同：
      1）通过send发送的是一个message对象, 会被handler的 handleMessage()函数处理；
      2）而通过post方法发送的是一个runnable对象，则会自己执行。


      每个带图形界面的应用启动后，都会创建一个主线程，可称之为UI线程。
      这个线程自动就会创建一个message queue，来自于系统的消息都会投放到这个message queue里面，
      并按先进先出的顺序处理。


      UI线程图形界面中的view可通过post方法向GUI线程的message queue投递一个runnable。
     对于除UI线程以外的其他线程，创建时缺省并没有message queue，
     而对于UI线程，则可以直接（比如在onCreate）创建一个handler并重载handleMessage，
     省去创建message queue的过程。

作者 east

年度归档2021