java复制代码/**
 * 每个人每小时限制触发次数
 */
private final int LOCK_TIMES = 15;

// 自定义Key
String key = "Ltz:" + sid;
// 获取已触发次数
String sendUser = redisTemplate.opsForValue().get(key);

// 为空，说明之前没有触发过
if (ObjectUtil.isEmpty(sendUser)) {
    // 空，说明是第一次，写入1，并且设置过期时间（1小时）
    redisTemplate.opsForValue().set(key, "1", 1, TimeUnit.HOURS);
} else {
    // 后续发送
    if (Integer.parseInt(sendUser) >= LOCK_TIMES) {
        // 超过限制次数
        // TODO
    }
    redisTemplate.opsForValue().increment(key);
}

sql复制代码ERR value is not an integer or out of range

kotlin复制代码当一个满足一些定向广告的请求到达时：
if 广告预算消耗完 {
    continue
} else {
    选择一个（消耗/预算）值最小的一个广告
}

go复制代码当一个满足一些定向广告的请求到达时：
if 广告预算消耗完 {
    continue
} else {
    选择一个`缩放出价`值最大的广告
}

go复制代码type ad struct {
	cost  float64
	total float64
	price float64
}

func scaled(price, cost, total float64) float64 {
	return price * (1.0 - math.Pow(math.E, cost/total-1))
}

func main() {
	a := &ad{0, 100, 1}
	b := &ad{0, 100, 0.01}
	// 模拟`男,游戏`到达时，a和b同时消耗
	for i := 0; i < 100; i++ {
		aCp := scaled(a.price, a.cost, a.total)
		bCp := scaled(b.price, b.cost, b.total)
		if a.cost >= a.total || b.cost >= b.total {
			break
		}
		if aCp >= bCp {
			a.cost += a.price
		} else {
			b.cost += b.price
		}
	}
	// 模拟`男,运动`到达时，仅b可消耗
	for i := 0; i < 100; i++ {
		if b.cost >= b.total {
			break
		}
		b.cost += b.price
	}
	fmt.Println(a.cost + b.cost)
}

sql复制代码insert into order_tbl values (12, '1002', '2001', 1, 5);

bash复制代码select id, user_id, commodity_code， count， money from product where id = 12;

bash复制代码select id, user_id, commodity_code， count， money from product where id = 12;

less复制代码{
    "@class": "io.seata.rm.datasource.undo.BranchUndoLog",
    "xid": "172.27.0.2:8091:18207193960247322",
    "branchId": 18207193960247324,
    "sqlUndoLogs": [
        "java.util.ArrayList",
        [
            {
                "@class": "io.seata.rm.datasource.undo.SQLUndoLog",
                "sqlType": "INSERT",
                "tableName": "order_tbl",
                "beforeImage": {
                    "@class": "io.seata.rm.datasource.sql.struct.TableRecords$EmptyTableRecords",
                    "tableName": "order_tbl",
                    "rows": [
                        "java.util.ArrayList",
                        []
                    ]
                },
                "afterImage": {
                    "@class": "io.seata.rm.datasource.sql.struct.TableRecords",
                    "tableName": "order_tbl",
                    "rows": [
                        "java.util.ArrayList",
                        [
                            {
                                "@class": "io.seata.rm.datasource.sql.struct.Row",
                                "fields": [
                                    "java.util.ArrayList",
                                    [
                                        {
                                            "@class": "io.seata.rm.datasource.sql.struct.Field",
                                            "name": "id",
                                            "keyType": "PRIMARY_KEY",
                                            "type": 4,
                                            "value": 12
                                        },
                                        {
                                            "@class": "io.seata.rm.datasource.sql.struct.Field",
                                            "name": "user_id",
                                            "keyType": "NULL",
                                            "type": 12,
                                            "value": "1002"
                                        },
                                        {
                                            "@class": "io.seata.rm.datasource.sql.struct.Field",
                                            "name": "commodity_code",
                                            "keyType": "NULL",
                                            "type": 12,
                                            "value": "2001"
                                        },
                                        {
                                            "@class": "io.seata.rm.datasource.sql.struct.Field",
                                            "name": "count",
                                            "keyType": "NULL",
                                            "type": 4,
                                            "value": 1
                                        },
                                        {
                                            "@class": "io.seata.rm.datasource.sql.struct.Field",
                                            "name": "money",
                                            "keyType": "NULL",
                                            "type": 4,
                                            "value": 5
                                        }
                                    ]
                                ]
                            }
                        ]
                    ]
                }
            }
        ]
    ]
}

ini复制代码delete from order_tbl where id = 12;

java复制代码//BusinessService
@GlobalTransactional
public void purchase(String userId, String commodityCode, int orderCount) {
    LOGGER.info("purchase begin ... xid: " + RootContext.getXID()); 
    storageClient.deduct(commodityCode, orderCount); 
    orderClient.create(userId, commodityCode, orderCount); 
}

java复制代码    private void initClient() {
        // ...
        //init TM
        TMClient.init(applicationId, txServiceGroup, accessKey, secretKey);
        // ...
        //init RM
        RMClient.init(applicationId, txServiceGroup);
        // ...
        registerSpringShutdownHook();
    }

java复制代码// TMClient
public static void init(String applicationId, String transactionServiceGroup, String accessKey, String secretKey) {
    TmNettyRemotingClient tmNettyRemotingClient = TmNettyRemotingClient.getInstance(applicationId, transactionServiceGroup, accessKey, secretKey);
    tmNettyRemotingClient.init();
}

java复制代码@Override
    public void init() {
        timerExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                clientChannelManager.reconnect(getTransactionServiceGroup());
            }
        }, SCHEDULE_DELAY_MILLS, SCHEDULE_INTERVAL_MILLS, TimeUnit.MILLISECONDS);
        if (NettyClientConfig.isEnableClientBatchSendRequest()) {
            mergeSendExecutorService = new ThreadPoolExecutor(MAX_MERGE_SEND_THREAD,
                MAX_MERGE_SEND_THREAD,
                KEEP_ALIVE_TIME, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(),
                new NamedThreadFactory(getThreadPrefix(), MAX_MERGE_SEND_THREAD));
            mergeSendExecutorService.submit(new MergedSendRunnable());
        }
        super.init();
        clientBootstrap.start();
    }

java复制代码public static void init(String applicationId, String transactionServiceGroup) {
    RmNettyRemotingClient rmNettyRemotingClient = RmNettyRemotingClient.getInstance(applicationId, transactionServiceGroup);
    rmNettyRemotingClient.setResourceManager(DefaultResourceManager.get());
    rmNettyRemotingClient.setTransactionMessageHandler(DefaultRMHandler.get());
    rmNettyRemotingClient.init();
}

java复制代码/**
 * The following will be scanned, and added corresponding interceptor
 */
@Override
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    try {
        synchronized (PROXYED_SET) {
            if (PROXYED_SET.contains(beanName)) {
                return bean;
            }
            interceptor = null;
            //check TCC proxy
            if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, applicationContext)) {
                //TCC interceptor, proxy bean of sofa:reference/dubbo:reference, and LocalTCC
                interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));
                ConfigurationCache.addConfigListener(ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,
                    (ConfigurationChangeListener)interceptor);
            } else {
                Class<?> serviceInterface = SpringProxyUtils.findTargetClass(bean);
                Class<?>[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);

                //#### <1> ####
                if (!existsAnnotation(new Class[]{serviceInterface})
                    && !existsAnnotation(interfacesIfJdk)) {
                    return bean;
                }
                
                if (globalTransactionalInterceptor == null) {
                    //#### <2> ####
                    globalTransactionalInterceptor = new GlobalTransactionalInterceptor(failureHandlerHook);
                    ConfigurationCache.addConfigListener(
                        ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION,
                        (ConfigurationChangeListener)globalTransactionalInterceptor);
                }
                interceptor = globalTransactionalInterceptor;
            }

            LOGGER.info("Bean[{}] with name [{}] would use interceptor [{}]", bean.getClass().getName(), beanName, interceptor.getClass().getName());
            if (!AopUtils.isAopProxy(bean)) {
                bean = super.wrapIfNecessary(bean, beanName, cacheKey);
            } else {
                //#### <3> ####
                AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
                Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));
                for (Advisor avr : advisor) {
                    advised.addAdvisor(0, avr);
                }
            }
            PROXYED_SET.add(beanName);
            return bean;
        }
    } catch (Exception exx) {
        throw new RuntimeException(exx);
    }
}

java复制代码@Override
public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
    Class<?> targetClass =
        methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null;
    Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
    if (specificMethod != null && !specificMethod.getDeclaringClass().equals(Object.class)) {
        final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);
        final GlobalTransactional globalTransactionalAnnotation =
            getAnnotation(method, targetClass, GlobalTransactional.class);
        final GlobalLock globalLockAnnotation = getAnnotation(method, targetClass, GlobalLock.class);
        boolean localDisable = disable || (degradeCheck && degradeNum >= degradeCheckAllowTimes);
        if (!localDisable) {
            if (globalTransactionalAnnotation != null) {
                return handleGlobalTransaction(methodInvocation, globalTransactionalAnnotation);
            } else if (globalLockAnnotation != null) {
                return handleGlobalLock(methodInvocation, globalLockAnnotation);
            }
        }
    }
    return methodInvocation.proceed();
}

Object handleGlobalTransaction(final MethodInvocation methodInvocation,
    final GlobalTransactional globalTrxAnno) throws Throwable {
    boolean succeed = true;
    try {
        return transactionalTemplate.execute(new TransactionalExecutor() {
            @Override
            public Object execute() throws Throwable {
                return methodInvocation.proceed();
            }
            // ...
        });
    }
    // ...
}

java复制代码public Object execute(TransactionalExecutor business) throws Throwable {
    // 1. Get transactionInfo
    TransactionInfo txInfo = business.getTransactionInfo();
    if (txInfo == null) {
        throw new ShouldNeverHappenException("transactionInfo does not exist");
    }
    // 1.1 Get current transaction, if not null, the tx role is 'GlobalTransactionRole.Participant'.
    GlobalTransaction tx = GlobalTransactionContext.getCurrent();

    // 1.2 Handle the transaction propagation.
    Propagation propagation = txInfo.getPropagation();
    SuspendedResourcesHolder suspendedResourcesHolder = null;
    try {
        // ...

        // 1.3 If null, create new transaction with role 'GlobalTransactionRole.Launcher'.
        if (tx == null) {
            tx = GlobalTransactionContext.createNew();
        }

        // set current tx config to holder
        GlobalLockConfig previousConfig = replaceGlobalLockConfig(txInfo);

        try {
            // 2. If the tx role is 'GlobalTransactionRole.Launcher', send the request of beginTransaction to TC,
            //    else do nothing. Of course, the hooks will still be triggered.
            beginTransaction(txInfo, tx);

            Object rs;
            try {
                // Do Your Business
                rs = business.execute();
            } catch (Throwable ex) {
                // 3. The needed business exception to rollback.
                completeTransactionAfterThrowing(txInfo, tx, ex);
                throw ex;
            }

            // 4. everything is fine, commit.
            commitTransaction(tx);

            return rs;
        } finally {
            //5. clear
            resumeGlobalLockConfig(previousConfig);
            triggerAfterCompletion();
            cleanUp();
        }
    } finally {
        // If the transaction is suspended, resume it.
        if (suspendedResourcesHolder != null) {
            tx.resume(suspendedResourcesHolder);
        }
    }
}

ini复制代码// 绑定 XID
RootContext.bind(xid);

// 解绑 XID
String xid = RootContext.unbind();

ini复制代码// 获取 XID
String xid = RootContext.getXID();

csharp复制代码    public static boolean inGlobalTransaction() {
        return CONTEXT_HOLDER.get(KEY_XID) != null;
    }

java复制代码public class ThreadLocalContextCore implements ContextCore {

    private ThreadLocal<Map<String, String>> threadLocal = new ThreadLocal<Map<String, String>>() {
        @Override
        protected Map<String, String> initialValue() {
            return new HashMap<String, String>();
        }

    };

    @Override
    public String put(String key, String value) {
        return threadLocal.get().put(key, value);
    }

    @Override
    public String get(String key) {
        return threadLocal.get().get(key);
    }

    @Override
    public String remove(String key) {
        return threadLocal.get().remove(key);
    }
}

scss复制代码// 挂起（暂停）
String xid = RootContext.unbind();

// TODO: 运行在全局事务外的业务逻辑

// 恢复全局事务上下文
RootContext.bind(xid);

java复制代码@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) servletRequest;
    String xid = req.getHeader(RootContext.KEY_XID.toLowerCase());
    boolean isBind = false;
    if (StringUtils.isNotBlank(xid)) {
        RootContext.bind(xid);
        isBind = true;
    }
    try {
        filterChain.doFilter(servletRequest, servletResponse);
    } finally {
        if (isBind) {
            RootContext.unbind();
        }
    }
}

java复制代码@Override
public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
    HttpRequestWrapper requestWrapper = new HttpRequestWrapper(httpRequest);
    String xid = RootContext.getXID();
    if (StringUtils.isNotEmpty(xid)) {
        requestWrapper.getHeaders().add(RootContext.KEY_XID, xid);
    }

    return clientHttpRequestExecution.execute(requestWrapper, bytes);
}

java复制代码try {
    // Do Your Business
    rs = business.execute();
} catch (Throwable ex) {
    // 3. The needed business exception to rollback.
    completeTransactionAfterThrowing(txInfo, tx, ex);
    throw ex;
}

java复制代码public void debit(String userId, BigDecimal orderMoney) {
    String url = "http://127.0.0.1:8083?userId=" + userId + "&orderMoney=" + orderMoney;
    try {
        restTemplate.getForEntity(url, Void.class);
    } catch (Exception e) {
        log.error("debit url {} ,error:", url, e);
        throw new RuntimeException();
    }
}

java复制代码public boolean isError() {
   return (is4xxClientError() || is5xxServerError());
}

protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
   String statusText = response.getStatusText();
   HttpHeaders headers = response.getHeaders();
   byte[] body = getResponseBody(response);
   Charset charset = getCharset(response);
   String message = getErrorMessage(statusCode.value(), statusText, body, charset);

   switch (statusCode.series()) {
      case CLIENT_ERROR:
         throw HttpClientErrorException.create(message, statusCode, statusText, headers, body, charset);
      case SERVER_ERROR:
         throw HttpServerErrorException.create(message, statusCode, statusText, headers, body, charset);
      default:
         throw new UnknownHttpStatusCodeException(message, statusCode.value(), statusText, headers, body, charset);
   }
}

java复制代码private Map<String, String> mapStr;

yaml复制代码map-str:
    a: aaa
    b: bbb

properties复制代码map-str.a=aa
map-str.b=bb

java复制代码@Autowired
private Config config;

@Test
public void testConfig() {
    // {a=aaa, b=bbb}
    System.out.println(config.getMapStr());
}

java复制代码public Map<String, MapConfig> mapConfig;

@Data
public static class MapConfig {
    private String key;
    private String val;
}

yaml复制代码map-config:
	map-one:
        key: one-key
        val: one-val
      map-two:
        key: two-key
        val: two-val

properties复制代码map-config.map-one.key=one-key
map-config.map-one.val=one-val
map-config.map-two.key=two-key
map-config.map-two.val=two-val

java复制代码@Autowired
private Config config;

@Test
public void testConfig() {
    // {map-one=Config.MapConfig(key=one-key, val=one-val), map-two=Config.MapConfig(key=two-key, val=two-val)}
    System.out.println(config.getMapStr()); 
}

java复制代码private List<String> listStr;

yaml复制代码list-str:
      - a
      - b

properties复制代码list-str[0]=a
list-str[1]=b

java复制代码@Autowired
private Config config;

@Test
public void testConfigGroup() {
    // [a, b]
    System.out.println(config.getListStr());
}

java复制代码private List<User> listObj;

@Data
public static class User {
    String age;
    String name;
}

yaml复制代码list-obj:
      - age: 23
        name: 张三
      - age: 20
        name: 李四

properties复制代码list-obj[0].age=23
list-obj[0].name=张三
list-obj[1].age=20
list-obj[1].name=李四

java复制代码@Autowired
private Config config;

@Test
public void testConfigGroup() {
    // [Config.User(age=23, name=张三), Config.User(age=20, name=李四)]
    System.out.println(config.getListObj());
}

ruby复制代码下载地址： https://github.com/xuxueli/xxl-job/releases
文档地址： https://www.xuxueli.com/xxl-job/
本人下载版本为2.3.0

复制代码脚本存放路径： xxl-job-2.3.0\doc\db\tables_xxl_job.sql

css复制代码配置文件路径： xxl-job-2.3.0\xxl-job-admin\src\main\resources\application.properties
修改数据库配置和邮箱配置，如下：

css复制代码启动类路径： xxl-job-2.3.0\xxl-job-admin\src\main\java\com\xxl\job\admin\XxlJobAdminApplication.java

bash复制代码地址： http://localhost:8080/xxl-job-admin
用户名 admin 密码 123456

复制代码在另一个springboot应用中添加maven配置

xml复制代码<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.3.0</version>
</dependency>

复制代码application.yml

kotlin复制代码
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job config
 *
 * @author xuxueli 2017-04-28
 */
@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appName;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

    @Bean(initMethod = "start", destroyMethod = "destroy")
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appName);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }

}

scala复制代码import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.handler.annotation.XxlJob;
import org.springframework.stereotype.Component;

@Component
public class SampleXxlJobHandler extends IJobHandler {

    @Override
    @XxlJob(value = "sampleXxlJobHandler")
    public void execute() throws Exception {
        System.out.println("自动任务" + this.getClass().getSimpleName() + "执行");
    }
}

复制代码在执行器管理页面，点击新增按钮，弹出新增框。输入AppName （与第7点中配置的appname保持一致），名称，注册方式默认自动注册，点击保存。

复制代码在任务管理页面，选择上一步新建的执行器，点击新增按钮，弹出新增框。输入任务描述，负责人，cron表达式（输入框右侧有按钮，点开可以辅助自动生成cron表达式），jobHandler（需要与第9步中的XxlJob注解中的值一致），点击保存。

复制代码启动配置自动任务的springboot服务，在任务管理页面选中要执行的自动任务操作按钮右侧下拉三角，选择执行一次，查看执行结果。
正常开发中，点击启动保持任务一直执行。
在调度日志页面，可以搜索查看日志。

scss复制代码//判断是否弹窗
PlanManager.ensureShowDialog(data);
//数据缓存到数据库
enqueueEventMessage(data);

scss复制代码// 监控数据，并传给注册接口的地方
DataMonitorInterface.trackEvent(data);
// 数据缓存到数据库
mMessages.enqueueEventMessage(eventType.getEventType(), dataObj);

typescript复制代码public class SFDataMonitorImpl{
    public void trackEvent(String data){  
        mSFPlanTaskManager.addTriggerTask(new Runnable() {
         //判断是否弹窗
            PlanManager.ensureShowDialog(data)
        }
   }
}

java复制代码public class SFPlanTriggerRunnable implements Runnable {  
    @Override
    public void run() {
        Runnable downloadTask = mSFPlanTaskManager.getTriggerTask();
        mPool.execute(downloadTask);
    }
}

less复制代码readLocalPlanData(new Callback() {
    @Override
    public void onFailure(int code, String errorMessage) {
         
    }
 
    @Override
    public void onResponse(String response) {
        //弹窗判断线程启动
        new TriggerThread().start();
    }
});

java复制代码public class SFPlanTriggerRunnable implements Runnable {  
    @Override
    public void run() {
        Runnable downloadTask = mSFPlanTaskManager.getTriggerTask();                
        mPool.submit(downloadTask).get();
    }
}

ini复制代码-a: #指定输出文件名的后缀长度(默认为2个:aa,ab...)
-d: #指定输出文件名的后缀用数字代替
-l: #行数分割模式(指定每多少行切成一个小文件;默认行数是1000行)
-b: #二进制分割模式(支持单位:k/m)
-C: #文件大小分割模式(切割时尽量维持每行的完整性)

split [-a] [-d] [-l <行数>] [-b <字节>] [-C <字节>] [要切割的文件] [输出文件名]

shell复制代码# 行切割文件
$ split -l 300000 users.sql /data/users_

# 使用数字后缀
$ split -d -l 300000 users.sql /data/users_

# 按字节大小分割
$ split -d -b 100m users.sql /data/users_

sql复制代码# 帮助信息
$ split --help
Usage: split [OPTION]... [FILE [PREFIX]]
Output pieces of FILE to PREFIXaa, PREFIXab, ...;
default size is 1000 lines, and default PREFIX is 'x'.

With no FILE, or when FILE is -, read standard input.

Mandatory arguments to long options are mandatory for short options too.
  -a, --suffix-length=N   generate suffixes of length N (default 2)            后缀名称的长度(默认为2)
      --additional-suffix=SUFFIX  append an additional SUFFIX to file names
  -b, --bytes=SIZE        put SIZE bytes per output file                       每个输出文件的字节大小
  -C, --line-bytes=SIZE   put at most SIZE bytes of records per output file    每个输出文件的最大字节大小
  -d                      use numeric suffixes starting at 0, not alphabetic   使用数字后缀代替字母后缀
      --numeric-suffixes[=FROM]  same as -d, but allow setting the start value
  -e, --elide-empty-files  do not generate empty output files with '-n'        不产生空的输出文件
      --filter=COMMAND    write to shell COMMAND; file name is $FILE           写入到shell命令行
  -l, --lines=NUMBER      put NUMBER lines/records per output file             设定每个输出文件的行数
  -n, --number=CHUNKS     generate CHUNKS output files; see explanation below  产生chunks文件
  -t, --separator=SEP     use SEP instead of newline as the record separator;  使用新字符分割
                            '\0' (zero) specifies the NUL character
  -u, --unbuffered        immediately copy input to output with '-n r/...'     无需缓存
      --verbose           print a diagnostic just before each                  显示分割进度
                            output file is opened
      --help     display this help and exit                                    显示帮助信息
      --version  output version information and exit                           显示版本信息
The SIZE argument is an integer and optional unit (example: 10K is 10*1024).
Units are K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000).

CHUNKS may be:
  N       split into N files based on size of input
  K/N     output Kth of N to stdout
  l/N     split into N files without splitting lines/records
  l/K/N   output Kth of N to stdout without splitting lines/records
  r/N     like 'l' but use round robin distribution
  r/K/N   likewise but only output Kth of N to stdout

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
Full documentation at: <http://www.gnu.org/software/coreutils/split>
or available locally via: info '(coreutils) split invocation'

ini复制代码-n: #显示行号
-e: #以$字符作为每行的结尾
-t: #显示TAB字符(^I)
cat [-n] [-e] [-t] [输出文件名]

sql复制代码# 帮助信息
$ cat --h
Usage: cat [OPTION]... [FILE]...
Concatenate FILE(s) to standard output.

With no FILE, or when FILE is -, read standard input.

  -A, --show-all           equivalent to -vET
  -b, --number-nonblank    number nonempty output lines, overrides -n
  -e                       equivalent to -vE
  -E, --show-ends          display $ at end of each line
  -n, --number             number all output lines
  -s, --squeeze-blank      suppress repeated empty output lines
  -t                       equivalent to -vT
  -T, --show-tabs          display TAB characters as ^I
  -u                       (ignored)
  -v, --show-nonprinting   use ^ and M- notation, except for LFD and TAB
      --help     display this help and exit
      --version  output version information and exit

Examples:
  cat f - g  Output f's contents, then standard input, then g's contents.
  cat        Copy standard input to standard output.

GNU coreutils online help: <http://www.gnu.org/software/coreutils/>
Full documentation at: <http://www.gnu.org/software/coreutils/cat>
or available locally via: info '(coreutils) cat invocation'

c复制代码sizeof(long long) >=sizeof(long) >= sizeof(int)

c复制代码bit：比特位
byte： 字节  1byte = 8bit
kb = 1024byte
mb = 1024 kb
gb = 1024mb
tb = 1024 gb
pb = 1024 tb

c复制代码如： 3.14
	 a

c复制代码int n = 100;
int arr[n] ={0}; //错误，[]内的必需为常数 ，写成变量是变长数组，而C99才支持变长数组的概念

const int  n = 100;	//n不是常量，n只是具有常属性，不能被修改而已
int arr[n] = {0}; 	//错误，

c复制代码#define Max 100
int main()
{
    int a  =Max;
    int arr[Max] = {0};		//正确，因为#define定义出来的Max是常量
    printf("%d\n",a);
    Max = 200;		//错误  Max为常量，不能被修改
    return 0;
}

c复制代码enum Sex		//enum Sex 是枚举类型
{
    //枚举的可能取值--枚举常量，可以被赋值，否则第一个数从0开始，数值依次往下+1
    MALE,			
    FEMALE,
    SECRET
};		//注意要有分号

注意：枚举常量后面跟的是逗号 不是分号
     最后一个枚举常量后面可以不跟逗号，其余要有逗号

c复制代码enum Sex
{
	MALE,
	FEMALE,
	SECRET
};
int main()
{
	enum Sex s = SECRET;	//s是枚举变量，值是SECRET对应的值
    s = 10;	//正确，s是变量，可以更改s的值，
    // MALE = 4;   //ERR  因为MALE是常量，不能被修改
    
    //若枚举常量不赋值，默认从0开始，值往下+1
	printf("%d\n", MALE);	//0
	printf("%d\n", FEMALE);	//1
	printf("%d\n", SECRET);	//2    
	return 0;
}

c复制代码enum Sex
{
	MALE=3,
	FEMALE=7,
	SECRET
};
int main()
{
	printf("%d\n", MALE);	//3
	printf("%d\n", FEMALE);	//7 
	printf("%d\n", SECRET);	//8	//SECRET未被赋值，值顺着FEMALE往下+1
	return 0;
}

c复制代码//c99
int n = 10;
int arr[n] = {0};	//err 变长数组不可以初始化

int arr[n];	//正确

java复制代码//饿汉式
private static Singleton singleton = new Singleton();

java复制代码//懒汉式
private static Singleton singleton;
public static Singleton getSingleton(){
    if (singleton == null) {
        singleton = new Singleton(); //被动创建，在真正需要使用时才去创建
    }
    return singleton;
}

java复制代码//双重判断加锁机制
private volatile static Singleton instance;
//程序运行时创建一个静态只读的进程辅助对象
public static Singleton GetInstance() {
    //先判断是否存在，不存在再加锁处理
    if (instance == null){
        synchronized (Singleton.class){
            if(instance == null){
                instance = new Singleton();
            }
        }
    }
    return instance;
}

java复制代码//静态初始化
private static readonly Singleton instance= new Singleton();
public static Singleton GetInstance(){
    return instance;
}

java复制代码public interface Sender{  public void send();  }  
public class MailSender implements Sender {  
    @Override  
    public void send() {  
        System.out.println("this is mailsender!");  
    }  
}
public class SmsSender implements Sender {  
    @Override  
    public void send() {  
        System.out.println("this is sms sender!");  
    }  
}
public class SendFactory {  
    public Sender produce(String type) {  
        if ("mail".equals(type)) {  
            return new MailSender();  
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            return null;  
        }  
    } 
    //若还有其他产品 则在工厂里加对应的 produce 方法
}

java复制代码@Data
class Product {
    private String name;
    private String price;
    // Product 的建造者  Builder
    public static class Builder{
        public static Builder builder(){
            Builder builder = Builder();
        }
        private Product product = new Product();
        public Builder name(String name){ product.name = name; return this;}
        public Builder price(String price){ product.price = price; return this; }
        //返回产品对象
        public Product build() { return product; }
    }
}

java复制代码//类的适配器模式
public class Source {  
    public void sayHello() {  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
// Source 用 Adapter 适配成 Targetable
public class Adapter extends Source implements Targetable {  
    @Override  
    public void hi() {  
        System.out.println("csc:hi!");  
    }  
}

java复制代码//对象的适配器模式
public class Source {  
    public void sayHello() {  
        System.out.println("lwl:hello!");  
    }  
}  
public interface Targetable {  
    /* Source方法相同 */  
    public void sayHello();  
    /* 新增的方法 */  
    public void hi();  
}
//  Source的对象适配成 Targetable
public class Adapter implements Targetable {
    private Source source;  
    public Adapter(Source source){ this.source = source; }
    public void sayHello(){ source.sayHello(); }
    @Override  
    public void hi() {  
        System.out.println("csc:hi!");  
    }  
}

java复制代码public interface Show(){ public void acting(); }
public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}  
public class DecoratorArtist implements Show{
    Artist artist;
    DecoratorArt(Artist artist){
        this.artist = artist;
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //增强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //增强的功能
    }
}

java复制代码public class Artist implements Show {  
    public void acting(){
        System.out.println("lwl 在唱歌!");  
    }
}
public class ProxyArtist implements Show{
    Artist artist;
    ProxyArtist(){ 
        this.artist = new Artist();//屏蔽了 artist 对象的创建
    }
    public void acting(){
        System.out.println("lwl 在弹钢琴!"); //增强的功能
        this.artist.acting(); 
        System.out.println("表演完毕!"); //增强的功能
    }
}
public class Demo {
    public static void main(String[] arg){
        Show show = new ProxyArtist();
        show.acting();
    }
}

java复制代码public interface FileSystem(){ 
  public void open(int file); 
  public String loading(int file); 
  public void store(int file, String data); 
}
//网络上的文件系统
public class NetFileSystem implements FileSystem {  
  public void open(int file){ System.out.println(" netfile opening...."); }
  public String loading(int file) {System.out.println(" net loading ...."); }  
  public void store(int file, String data) {System.out.println(" send to network ...."); }  
}
//磁盘文件系统
public class DiskFileSystem implements FileSystem{
  public void open(int file){ System.out.println(" disk opening...."); }
  public String loading(int file) {System.out.println(" disk loading ...."); } 
  public void store(int file, String data) {System.out.println(" write back disk ...."); }   
}
public class Linux {
    FileSystem fileSystem; 
    //底层功能提供接口，桥接模式：功能和具体实现分离
    //可以桥接 NetFileSystem 或者 DiskFileSystem 作为文件系统
    public void set(FileSystem fileSystem){ this.fileSystem = fileSystem; }
    //上层功能读数据
    public String read(int file){
        fileSystem.open(file);
        ... // Linux 自己的系统功能
        fileSystem.loading(file);
        ... 
    }
    //上层功能写数据
    public String write(int file, String data){
        fileSystem.open(file);
        ....
        fileSystem.store(file,data);
    }
}

java复制代码public class ConnectionPool {  
    private Vector<Connection> pool;  
    /*公有属性*/  
    private String url = "jdbc:mysql://localhost:3306/test";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
    public ConnectionPool() {  
        pool = new Vector<Connection>(poolSize);  
        for (int i = 0; i < poolSize; i++) {  
            Class.forName(driverClassName);  
                // 每一个 conn 共享了 driverClassName ，url, username, password 等属性
                Connection conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);
            }
    }
    ....
}

java复制代码public class DAO { 
    public void queryData(){
        System.out.print(" query data ")
    }
}
public class Deal {  
    public void dealData(){
        System.out.print(" dealing data ")
    }
}
public class Sender {  
    public void send(){
        System.out.print(" send data ")
    }
}
public class Service(){
    private DAO dao;  
    private Deal deal;  
    private Sender sender;
    //封装 DAO，Deal，Sender 的功能，统一对外提供服务
    public void reponse(){
        dao.queryData();
        deal.dealData();
        sender.send();
    }
}

java复制代码// 上学的策略
abstract class Strategy{
    private static final Map<Integer,Strategy> strategyMap = new ConcurrentHashMap<>();
    public Strategy(){
        strategyMap.put(getType(), this);
    }
    public static Strategy routing(int type){
        return strategyMap.get(type);
    }
    abstract int getType();
    abstract void method(); //留待子类实现差异
}
//跑路去学校
class RunningStrategy extends Strategy{
    int getType() { return 0; }
    void method() { System.out.println(" Run to school "); }
}
//公交去学校
class BusStrategy extends Strategy{
    int getType() { return 1; }
    void method() { System.out.println(" Go to school by bus "); }
}
//飞去学校
class FlyStrategy extends Strategy{
    int getType() { return 2; }
    void method() { System.out.println(" Fly to school "); }
}
class Context{
    //使用不同的策略
    void method(int strategy){
        Strategy.routing(strategy).method();
    }
}

java复制代码abstract class AbstractHandler{
    // handle是抽象出来的共同逻辑
    void handle(String data){
        System.out.println("通用逻辑1...");
        stepOne(data);
        System.out.println("通用逻辑2...");
        stepTwo(data);
        System.out.println("通用逻辑3...");
    }
    abstract void stepOne(String data); //留待子类实现差异
    abstract void stepTwo(String data); //留待子类实现差异
}
class HelloHandler extends AbstractHandler{
    @Override
    void stepOne(String data) {
        System.out.println("hello: "+data);
    }
    @Override
    void stepTwo(String data) {
        System.out.println("hi: "+data);
    }
}

java复制代码//迭代的抽象接口
public interface Iterator {  
    //前移  
    public Object previous();  
    //后移  
    public Object next();  
    public boolean hasNext();   
} 
// 数组的迭代类
public class ArrayIterator implements Iterator {  
    private Object[] datas; 
    private int cur = 0;  
    public ArrayIterator(Object[] datas){  
        this.datas = datas;  
    }  
    public String previous() {  
        if(cur > 0){ cur--;}  
        return datas[cur];  
    }  
    public Object next() {  
        if(cur < datas.length-1){ cur++;}  
        return datas[cur];  
    }  
    public boolean hasNext() {  
        return pos < datas.length-1 ? true ：false;
    }  
}

java复制代码abstract class Handler<T,R> {
    private Handler<R,?> next;
    abstract R handle(T data);
    public void setNext(Handler<R, ?> next){ this.next = next; }
    public void loopHandle(T data){
        R result = this.handle(data);
        if(next!=null && result!=null ) { next.loopHandle(result); }
    }
}
//负责问候
class HelloHandler extends Handler<String, Integer> {
    Integer handle(String data) {
        System.out.println(data + " hello! ");
        return 10;
    }
}
//负责计数
class CountHandler extends Handler<Integer, Double> {
    Double handle(Integer data) {
        System.out.println(" it is " + data);
        return 2.0;
    }
}
public class demo{
    public static void main(String[] args){
        HelloHandler hello = new HelloHandler();
        CountHandler count = new CountHandler();
        hello.setNext(count);
        hello.loopHandle("lwl");
    }
}

java复制代码//观察者
public abstract class Observer<T> {
    public abstract void update(T data);
}
// 被观察对象
public class Subject<T> {
    private List<Observer<T>> observers = new ArrayList<>();
    private T state;
    public void deal() { 
        ....// 逻辑处理
        //如果修改了 state，通知观察者
        if(...) notifyAllObservers();
    }
    //增加一个观察观察
    public void observe(Observer<T> observer) {
        observers.add(observer);
    }
    public void notifyAllObservers() {
        for (Observer<T> observer : observers) {
            observer.update(state);
        }
    }
}

java复制代码interface State<T> {
    //当前状态进行处理数据，并返回下一个状态
    abstract State<T> action(T data);
}
@Data
class Context<T>{
    private State<T> state;
    public void invoke(T data){
        state != null ? state = state.action(data) : System.out.println(" nothing " + data);
    }
}
// HelloState -> HiState
class HelloState implements State<String>{
    public State<String> action(String data) {
        System.out.println("hello!" + data);
        return new HiState();
    }
}
// HiState -> FineState
class HiState implements State<String>{
    public State<String> action(String data) {
        System.out.println("how are you ?" + data);
        return new FineState();
    }
}
//最后的状态
class FineState implements State<String>{
    public State<String> action(String data) {
        System.out.println("I am  fine!");
        return null;
    }
}
public class demo{
    public static void main(String[] args){
        Context<String> context = new Context<>();
        context.setState(new HelloState());
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
        context.invoke("lwl");
    }
}

java复制代码@Data
public class Memento { 
    private String state;
    public Memento(String state){ this.state = state; }
}
@Data
public class Storage { 
    private String value;  
    public void storeMemento(){
        return new Memento(value);  
    }
    public void restoreMemento(Memento memento){  
        this.value = memento.getValue();  
    }
    public void action(){ System.out.println(" Storage类逻辑运行 ")；}
      
}
public class MementoPatternDemo { 
    public static void main(String[] args) {
        Storage storage = new Storage();
        storage.setValue(1);
        storage.storeMemento();//备忘，一下
        storage.action();//....逻辑运行
        restoreMemento(Memento memento);//使用备忘录的恢复状态
    }
}

xml复制代码  <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>18.0</version>
  </dependency>

java复制代码EventBus eventBus=new EventBus();

java复制代码public class MyEventListener{
	private static int numberEvents;
	private static List<String> eventsList=new ArrayList<>();
	@Subscribe
	public void myEvent(String event) {
		System.out.println(event);
		numberEvents++;
 }

java复制代码import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class EventBusTest {

   class EventListener{
      private  int numberEvents;
      @Subscribe
      public void myEvent(String event) {
          System.out.println(event);
          numberEvents++;
      }
      public  int getNumberEvents(){
          return  numberEvents;
      }
	}

	@Test
	public void testEventBusSimpleTest(){
		EventBus eventBus=new EventBus();
		EventListener listener = new EventListener();
		eventBus.register(listener);
		eventBus.post("event1");
		eventBus.post("event2");
		assertEquals(2, listener.getNumberEvents());
	}
}

java复制代码class Transaction {
    private final String transactionName;
    private double amount = 0.0;
    public Transaction(String transactionName, Double amount) {
        this.transactionName = transactionName;
        this.amount = amount;
    }
    public String getTransactionName() {
        return transactionName;
    }
    public double getAmount() {
        return amount;
    }
    @Override
    public String toString() {
        return "[transaction with name " + transactionName + " and amount " + amount + "]";
    }
}

java复制代码class SendPaymentListener {
    @Subscribe
    private void sendToPayment(Transaction transaction) {
        System.out.println("【付款方】交易" + transaction.getTransactionName() + "交易完成，金额:" + transaction.getAmount());
        // to do something...
    }
}

class SendReceiveListener {
    @Subscribe
    private void sendToPayment(Transaction transaction) {
        System.out.println("【收款方】交易" + transaction.getTransactionName() + "交易完成，金额:" + transaction.getAmount());
        // to do something...
    }
}

java复制代码public class PaymentService {

    static class EventBusFactory {
        //create an asynch bus in new Thread
        private static EventBus eventBus
            = new AsyncEventBus(Executors.newCachedThreadPool());
        public static EventBus getEventBus() {
            return eventBus;
        }
    }
    
    @Test
    public void testPayment() {
        //registering listeners
        EventBusFactory.getEventBus().register(new SendPaymentListener());
        EventBusFactory.getEventBus().register(new SendReceiveListener());
        EventBusFactory.getEventBus().post(new Transaction("交易001", 100.0));
    }
}