小小少年Boy
小小少年Boy

2020-02-20

RM的子服务列表

[TOC]

RMApplicationHistoryWriter
AsyncDispatcher
AdminService
RMActiveServices
–RMSecretManagerService
–ContainerAllocationExpirer
–AMLivelinessMonitor
–RMNodeLabelsManager
–RMStateStore
–RMApplicationHistoryWriter
–SystemMetricsPublisher
–NodesListManager
–ResourceScheduler
–SchedulerEventDispatcher
–NMLivelinessMonitor
–ResourceTrackerService
–ApplicationMasterService
–ClientRMService
–ApplicationMasterLauncher
–DelegationTokenRenewer
————————————————
版权声明：本文为CSDN博主「Jerry Shao」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44630798/article/details/89005651

1 ClientRMService初始化

在ResourceManager#RMActiveServices#serviceInit()方法中进行ClientRMService的创建

ResourceManager.RMActiveServices.serviceInit(){
    clientRM = createClientRMService();
    addService(clientRM);
    rmContext.setClientRMService(clientRM);
}

再看ClientRMService的serviceInit()方法,很简单就是为设置了下客户端绑定地址（即RM的RPC ip+port）

@Override
protected void serviceInit(Configuration conf) throws Exception {
    clientBindAddress = getBindAddress(conf);
    super.serviceInit(conf);
}
InetSocketAddress getBindAddress(Configuration conf) {
    return conf.getSocketAddr(
        YarnConfiguration.RM_BIND_HOST,
        YarnConfiguration.RM_ADDRESS,
        YarnConfiguration.DEFAULT_RM_ADDRESS,
        YarnConfiguration.DEFAULT_RM_PORT);
}

2 ResourceScheduler

在ResouceManager#RMActiveServices#serviceInit()方法中进行ResourceScheduler的创建;

进入createScheduler():根据配置文件中的参数反射创建scheduler实例，默认创建出CapacityScheduler对象。

ResourceManager.RMActiveServices.serviceInit(){
    // Initialize the scheduler
    scheduler = createScheduler();
    scheduler.setRMContext(rmContext);
    addIfService(scheduler);
    rmContext.setScheduler(scheduler);
}

protected ResourceScheduler createScheduler() {
    String schedulerClassName = conf.get(YarnConfiguration.RM_SCHEDULER,
                                         YarnConfiguration.DEFAULT_RM_SCHEDULER);
    LOG.info("Using Scheduler: " + schedulerClassName);
    try {
        Class schedulerClazz = Class.forName(schedulerClassName);
        if (ResourceScheduler.class.isAssignableFrom(schedulerClazz)) {
            return (ResourceScheduler) ReflectionUtils.newInstance(schedulerClazz,
                                                                   this.conf);
        } else {
            throw new YarnRuntimeException("Class: " + schedulerClassName
                                           + " not instance of " + ResourceScheduler.class.getCanonicalName());
        }
    } catch (ClassNotFoundException e) {
        throw new YarnRuntimeException("Could not instantiate Scheduler: "
                                       + schedulerClassName, e);
    }
}

由于scheduler被addIfService(scheduler)了，所以进入CapacityScheduler的serviceInit()

3 CapacityScheduler.java

[图片上传失败...(image-aeae3a-1582179940006)]

//存储队列信息
private Map queues = new ConcurrentHashMap();

进入CapacityScheduler的serviceInit()，先看super.serviceInit(conf)，再看initScheduler(configuration);

public void serviceInit(Configuration conf) throws Exception {
    Configuration configuration = new Configuration(conf);
    super.serviceInit(conf);
    initScheduler(configuration);
}

//AbstractYarnScheduler.java
@Override
 public void serviceInit(Configuration conf) throws Exception {
   //yarn.nm.liveness-monitor.expiry-interval-ms nm存活检测间隔，默认600s
   nmExpireInterval =
       conf.getInt(YarnConfiguration.RM_NM_EXPIRY_INTERVAL_MS,
         YarnConfiguration.DEFAULT_RM_NM_EXPIRY_INTERVAL_MS);
   //yarn.resourcemanager.work-preserving-recovery.scheduling-wait-ms 默认10s
   configuredMaximumAllocationWaitTime =
       conf.getLong(YarnConfiguration.RM_WORK_PRESERVING_RECOVERY_SCHEDULING_WAIT_MS,
         YarnConfiguration.DEFAULT_RM_WORK_PRESERVING_RECOVERY_SCHEDULING_WAIT_MS);
   //创建定期释放死亡NM上container的Timer，调度间隔为nmExpireInterval
   createReleaseCache();
   super.serviceInit(conf);
 }

private synchronized void initScheduler(Configuration configuration) throws
    IOException {
    this.conf = loadCapacitySchedulerConfiguration(configuration);
    //memory:minMem maxMem ; vcore:minVcores maxVcores
    validateConf(this.conf);
    //minimumMemory, minimumCores记录在Resource中返回
    this.minimumAllocation = this.conf.getMinimumAllocation();
    //初始化最大的资源给configuredMaxAllocation对象：会在ClusterNodeTracker.setConfiguredMaxAllocation(Resource)中使用
    //ReentrantReadWriteLock锁，然后clone resource对象，复制给configuredMaxAllocation对象
    initMaximumResourceCapability(this.conf.getMaximumAllocation());
    //创建出资源计算器对象DefaultResourceCalculator
    this.calculator = this.conf.getResourceCalculator();
    //yarn.scheduler.include-port-in-node-name 默认false
    this.usePortForNodeName = this.conf.getUsePortForNodeName();
    //调度的app列表
    this.applications = new ConcurrentHashMap>();
    //获取节点标签管理器对象
    this.labelManager = rmContext.getNodeLabelManager();
    authorizer = YarnAuthorizationProvider.getInstance(yarnConf);
    //初始化队列
    initializeQueues(this.conf);
    //是否开启异步资源调度 yarn.scheduler.capacity.schedule-asynchronously.enable，默认false
    scheduleAsynchronously = this.conf.getScheduleAynschronously();
    //异步调度间隔 yarn.scheduler.capacity.schedule-asynchronously.scheduling-interval-ms，默认5s
    asyncScheduleInterval =
        this.conf.getLong(ASYNC_SCHEDULER_INTERVAL,DEFAULT_ASYNC_SCHEDULER_INTERVAL);
    //如果开启了异步调度，则创建异步调度线程
    if (scheduleAsynchronously) {
        asyncSchedulerThread = new AsyncScheduleThread(this);
    }

    LOG.info("Initialized CapacityScheduler with " +
             "calculator=" + getResourceCalculator().getClass() + ", " +
             "minimumAllocation=<" + getMinimumResourceCapability() + ">, " +
             "maximumAllocation=<" + getMaximumResourceCapability() + ">, " +
             "asynchronousScheduling=" + scheduleAsynchronously + ", " +
             "asyncScheduleInterval=" + asyncScheduleInterval + "ms");
}

重点来分析下初始化队列initializeQueues(this.conf);

（1）解析配置项，构建队列树
（2）构建队列和用户/组的映射

@Lock(CapacityScheduler.class)
private void initializeQueues(CapacitySchedulerConfiguration conf)
    throws IOException {
    //构建队列树，树根为root队列   
    root = parseQueue(this, conf, null, CapacitySchedulerConfiguration.ROOT,queues, queues, noop);
    labelManager.reinitializeQueueLabels(getQueueToLabels());
    LOG.info("Initialized root queue " + root);
    initializeQueueMappings();
    setQueueAcls(authorizer, queues);
}

(1) 解析配置项，构建队列树

进入parseQueue，解析队列

@Lock(CapacityScheduler.class)
static CSQueue parseQueue(
    CapacitySchedulerContext csContext,
    CapacitySchedulerConfiguration conf,
    CSQueue parent, String queueName, Map queues,
    Map oldQueues,
    QueueHook hook) throws IOException {
    CSQueue queue;
    //fullQueueName=root
    String fullQueueName = (parent == null) ? queueName
        : (parent.getQueuePath() + "." + queueName);
    //获取子队列列表，即读取配置项yarn.scheduler.capacity.root.queues
    String[] childQueueNames = conf.getQueues(fullQueueName);
    //队列否开启了资源预留，即读取配置项yarn.scheduler.capacity.root.reservable,默认为false
    boolean isReservableQueue = conf.isReservable(fullQueueName);
    //如果没有子队列则创建LeafQueue
    if (childQueueNames == null || childQueueNames.length == 0) {
        if (null == parent) {
            throw new IllegalStateException(
                "Queue configuration missing child queue names for " + queueName);
        }
        // Check if the queue will be dynamically managed by the Reservation
        // system
         // 如果队列开启了资源预留，则创建PlanQueue,该类型的queue会被ReservationSystem管理
        if (isReservableQueue) {
            queue =
                new PlanQueue(csContext, queueName, parent,
                              oldQueues.get(queueName));
        } else {
            queue = new LeafQueue(csContext, queueName, parent,oldQueues.get(queueName));

            // Used only for unit tests
            queue = hook.hook(queue);
        }
    } else {//有子队列则创建ParentQueue
        if (isReservableQueue) {
            throw new IllegalStateException(
                "Only Leaf Queues can be reservable for " + queueName);
        }
        //root队列构建
        ParentQueue parentQueue =
            new ParentQueue(csContext, queueName, parent, oldQueues.get(queueName));

        // Used only for unit tests
        queue = hook.hook(parentQueue);
        //root的子队列构建,递归调用parseQueue
        List childQueues = new ArrayList();
        for (String childQueueName : childQueueNames) {
            CSQueue childQueue =
                parseQueue(csContext, conf, queue, childQueueName,
                           queues, oldQueues, hook);
            childQueues.add(childQueue);
        }
        //为父队列设置子队列，即childQueues属性赋值，childQueues是个TreeSet按队列的capacity排序
        parentQueue.setChildQueues(childQueues);
    }

    if(queue instanceof LeafQueue == true && queues.containsKey(queueName)
       && queues.get(queueName) instanceof LeafQueue == true) {
        throw new IOException("Two leaf queues were named " + queueName
                              + ". Leaf queue names must be distinct");
    }
    queues.put(queueName, queue);

    LOG.info("Initialized queue: " + queue);
    return queue;
}

ParentQueue构建

public ParentQueue(CapacitySchedulerContext cs, 
                   String queueName, CSQueue parent, CSQueue old) throws IOException {
    super(cs, queueName, parent, old);
    //队列比较器 
    this.queueComparator = cs.getQueueComparator();
    //是否root队列
    this.rootQueue = (parent == null);
    //获取队列设置的capacity，参数：yarn.scheduler.capacity.root.rec.capacity,如果是root队列则直接是100
    float rawCapacity = cs.getConfiguration().getCapacity(getQueuePath());

    if (rootQueue &&
        (rawCapacity != CapacitySchedulerConfiguration.MAXIMUM_CAPACITY_VALUE)) {
        throw new IllegalArgumentException("Illegal " +
                                           "capacity of " + rawCapacity + " for queue " + queueName +
                                           ". Must be " + CapacitySchedulerConfiguration.MAXIMUM_CAPACITY_VALUE);
    }

    float capacity = (float) rawCapacity / 100;
    float parentAbsoluteCapacity = 
        (rootQueue) ? 1.0f : parent.getAbsoluteCapacity();
    float absoluteCapacity = parentAbsoluteCapacity * capacity; 

    float  maximumCapacity =
        (float) cs.getConfiguration().getMaximumCapacity(getQueuePath()) / 100;
    float absoluteMaxCapacity = 
        CSQueueUtils.computeAbsoluteMaximumCapacity(maximumCapacity, parent);

    QueueState state = cs.getConfiguration().getState(getQueuePath());

    Map acls = 
        cs.getConfiguration().getAcls(getQueuePath());

    //设置conf参数
    setupQueueConfigs(cs.getClusterResource(), capacity, absoluteCapacity,
                      maximumCapacity, absoluteMaxCapacity, state, acls, accessibleLabels,
                      defaultLabelExpression, capacitiyByNodeLabels, maxCapacityByNodeLabels, 
                      cs.getConfiguration().getReservationContinueLook());
    //子队列按队列比较器来进行排序
    this.childQueues = new TreeSet(queueComparator);

    LOG.debug("Initialized parent-queue " + queueName +
              " name=" + queueName + 
              ", fullname=" + getQueuePath()); 
}

LeafQueue构建

public LeafQueue(CapacitySchedulerContext cs, 
                 String queueName, CSQueue parent, CSQueue old) throws IOException {
    super(cs, queueName, parent, old);
    this.scheduler = cs;

    this.activeUsersManager = new ActiveUsersManager(metrics);
    this.minimumAllocationFactor = 
        Resources.ratio(resourceCalculator, 
                        Resources.subtract(maximumAllocation, minimumAllocation), 
                        maximumAllocation);

    float capacity = getCapacityFromConf();
    float absoluteCapacity = parent.getAbsoluteCapacity() * capacity;

    float maximumCapacity = 
        (float)cs.getConfiguration().getMaximumCapacity(getQueuePath()) / 100;
    float absoluteMaxCapacity = 
        CSQueueUtils.computeAbsoluteMaximumCapacity(maximumCapacity, parent);

    // Initially set to absoluteMax, will be updated to more accurate
    // max avail value during assignContainers
    absoluteMaxAvailCapacity = absoluteMaxCapacity;

    int userLimit = cs.getConfiguration().getUserLimit(getQueuePath());
    float userLimitFactor = 
        cs.getConfiguration().getUserLimitFactor(getQueuePath());

    int maxApplications =
        cs.getConfiguration().getMaximumApplicationsPerQueue(getQueuePath());
    if (maxApplications < 0) {
        int maxSystemApps = cs.getConfiguration().getMaximumSystemApplications();
        maxApplications = (int)(maxSystemApps * absoluteCapacity);
    }
    maxApplicationsPerUser = 
        (int)(maxApplications * (userLimit / 100.0f) * userLimitFactor);

    float maxAMResourcePerQueuePercent = cs.getConfiguration()
        .getMaximumApplicationMasterResourcePerQueuePercent(getQueuePath());
    int maxActiveApplications = 
        CSQueueUtils.computeMaxActiveApplications(
        resourceCalculator,
        cs.getClusterResource(), this.minimumAllocation,
        maxAMResourcePerQueuePercent, absoluteMaxCapacity);
    this.maxActiveAppsUsingAbsCap = 
        CSQueueUtils.computeMaxActiveApplications(
        resourceCalculator,
        cs.getClusterResource(), this.minimumAllocation,
        maxAMResourcePerQueuePercent, absoluteCapacity);
    int maxActiveApplicationsPerUser =
        CSQueueUtils.computeMaxActiveApplicationsPerUser(
        maxActiveAppsUsingAbsCap, userLimit, userLimitFactor);

    QueueState state = cs.getConfiguration().getState(getQueuePath());

    Map acls = 
        cs.getConfiguration().getAcls(getQueuePath());
    //set
    setupQueueConfigs(cs.getClusterResource(), capacity, absoluteCapacity,
                      maximumCapacity, absoluteMaxCapacity, userLimit, userLimitFactor,
                      maxApplications, maxAMResourcePerQueuePercent, maxApplicationsPerUser,
                      maxActiveApplications, maxActiveApplicationsPerUser, state, acls, cs
                      .getConfiguration().getNodeLocalityDelay(), accessibleLabels,
                      defaultLabelExpression, this.capacitiyByNodeLabels,
                      this.maxCapacityByNodeLabels,
                      cs.getConfiguration().getReservationContinueLook());

    if(LOG.isDebugEnabled()) {
        LOG.debug("LeafQueue:" + " name=" + queueName
                  + ", fullname=" + getQueuePath());
    }
    //app比较器，按appID排序
    Comparator applicationComparator = cs.getApplicationComparator();
    //pendingApp列表
    this.pendingApplications = new TreeSet(applicationComparator);
    //activeApp列表
    this.activeApplications = new TreeSet(applicationComparator);
}

ParentQueue和LeafQueue的一点说明：队列通过ParentQueue和LeafQueue构成了一颗树，app只能在LeafQueue上申请资源，LeafQueue保存了当前运行的app列表，app列表分两种：pendingApp列表和activeApp列表，两个列表都是按appID来排序的，即capacityScheduler在队列内部是按FIFO调度的。

(2) 构建队列和用户/组的映射

队列映射 initializeQueueMappings()：将用户/组和队列映射起来

private void initializeQueueMappings() throws IOException {
    //如果存在队列映射，它是否会覆盖用户指定的值？ 管理员可以使用此项将作业放入与用户指定的队列不同的队列中.
    overrideWithQueueMappings = conf.getOverrideWithQueueMappings();
    LOG.info("Initialized queue mappings, override: "
             + overrideWithQueueMappings);
    // Get new user/group mappings
    //指定用户/组到特定队列的映射 yarn.scheduler.capacity.queue-mappings
    List newMappings = conf.getQueueMappings();
    //check if mappings refer to valid queues
    for (QueueMapping mapping : newMappings) {
        if (!mapping.queue.equals(CURRENT_USER_MAPPING) &&
            !mapping.queue.equals(PRIMARY_GROUP_MAPPING)) {
            CSQueue queue = queues.get(mapping.queue);
            if (queue == null || !(queue instanceof LeafQueue)) {
                throw new IOException(
                    "mapping contains invalid or non-leaf queue " + mapping.queue);
            }
        }
    }
    //apply the new mappings since they are valid
    mappings = newMappings;
    // initialize groups if mappings are present
    if (mappings.size() > 0) {
        groups = new Groups(conf);
    }
}

capacity相关重要类

CSQueue 接口

CSQueue代表CapacityScheduler中分层队列树中的一个节点，使用这个类来保存队列的信息

ClusterNodeTracker

帮助程序库：-跟踪所有群集SchedulerNodes的状态-提供方便的方法来过滤和排序节点

ResourceCalculator

进行资源比较和操作

ParentQueue

PlanQueue

这表示由ReservationSystem管理的动态队列。从用户的角度来看，这等效于保留的LeafQueue，但从功能上讲，它是ParentQueue的子类。

4 AMLivelinessMonitor

在ResouceManager#RMActiveServices#serviceInit()方法中进行createAMLivelinessMonitor的创建

AMLivelinessMonitor amLivelinessMonitor = createAMLivelinessMonitor();
addService(amLivelinessMonitor);
rmContext.setAMLivelinessMonitor(amLivelinessMonitor);

AMLivelinessMonitor amFinishingMonitor = createAMLivelinessMonitor();
addService(amFinishingMonitor);
rmContext.setAMFinishingMonitor(amFinishingMonitor);

创建了两个AMLivelinessMonitor实例：amLivelinessMonitor代表运行中的AM，amFinishingMonitor代表完成中的AM。

进入createAMLivelinessMonitor()

protected AMLivelinessMonitor createAMLivelinessMonitor() {
    return new AMLivelinessMonitor(this.rmDispatcher);
}

//进入new AMLivelinessMonitor

//进入new AMLivelinessMonitor
public AMLivelinessMonitor(Dispatcher d) {
    super("AMLivelinessMonitor", new SystemClock());
    this.dispatcher = d.getEventHandler();
}

public void serviceInit(Configuration conf) throws Exception {
    super.serviceInit(conf);
    //am过期时间，yarn.am.liveness-monitor.expiry-interval-ms，默认10分钟
    int expireIntvl = conf.getInt(YarnConfiguration.RM_AM_EXPIRY_INTERVAL_MS,
                                  YarnConfiguration.DEFAULT_RM_AM_EXPIRY_INTERVAL_MS);
    //设置am过期间隔为10分钟
    setExpireInterval(expireIntvl);
    //设置am监控间隔为3分钟
    setMonitorInterval(expireIntvl/3);
}

AbstractLivelinessMonitor.java

@Override
protected void serviceStart() throws Exception {
    assert !stopped : "starting when already stopped";
    //将存储的AM的时间重置为当前时间
    resetTimer();
    //创建一个监控AM的线程
    checkerThread = new Thread(new PingChecker());
    checkerThread.setName("Ping Checker");
    //启动监控线程，不停的监控AM是否过期了
    checkerThread.start();
    super.serviceStart();
}

来看看监控线程的工作

private class PingChecker implements Runnable {
    @Override
    public void run() {
        while (!stopped && !Thread.currentThread().isInterrupted()) {
            synchronized (AbstractLivelinessMonitor.this) {
                //running是个map，元素为
                Iterator> iterator = running.entrySet().iterator();

                //avoid calculating current time everytime in loop
                long currentTime = clock.getTime();
                //所有AM进行当前时间和上次心跳汇报时间的间隔比较，如果超过设置的过期时间没有汇报心跳则认为AM过期了，然后会发起过期流程
                while (iterator.hasNext()) {
                    Map.Entry entry = iterator.next();
                    if (currentTime > entry.getValue() + expireInterval) {
                        iterator.remove();
                        //发起过期流程
                        expire(entry.getKey());
                        LOG.info("Expired:" + entry.getKey().toString() + 
                                 " Timed out after " + expireInterval/1000 + " secs");
                    }
                }
            }
            try {
                Thread.sleep(monitorInterval);
            } catch (InterruptedException e) {
                LOG.info(getName() + " thread interrupted");
                break;
            }
        }
    }
}

来看下过期流程：AMLivelinessMonitor.expire()

@Override
protected void expire(ApplicationAttemptId id) {
    dispatcher.handle(new RMAppAttemptEvent(id, RMAppAttemptEventType.EXPIRE));
}

即向RMAppAttemptImpl发送RMAppAttemptEventType.EXPIRE事件。

总结

capacity 使用Map queues = new ConcurrentHashMap()来记录队列，

使用CSQueue保存队列的具体信息

解析队列 的时候，使用递归来解析child队列，同时设置每个队列父亲队列，队列通过ParentQueue和LeafQueue构成了一颗树，app只能在LeafQueue上申请资源，LeafQueue保存了当前运行的app列表，app列表分两种：pendingApp列表和activeApp列表，两个列表都是按appID来排序的，即capacityScheduler在队列内部是按FIFO调度的。

问题1：queue = hook.hook(parentQueue);

问题2：addService()

参考：https://blog.csdn.net/weixin_44630798/article/details/89005651

你可能感兴趣的:(2020-02-20)

  • 2020-02-20操心 想要随心所欲的北极熊
    一说起孩子，总有说不完的话题，不是担心吃不饱，就是担心穿不暖，再不然就是担心拉不出屎，皮肤出皮疹，骨头长不好等等等等！只要话题一沾上“孩子”这两个字，总有说不完的话，唠不完的嗑！然而，当妈的，总是担心这个担心那个，还是阻止不了一些事情的发展走向。可谓心力憔悴！
  • 2020-02-20 郭尹
    em，最近看看到有关日记，文书的场面是什么时候呢？想了想，大概是昨天在看《朱莉、茱莉亚》时候吧。茱莉亚撰写食谱时候，与素未蒙面的编辑通信往来。朱莉为了改变自己一成不变的生活，开通博客定下一年内按照食谱做完五百多道菜的时候。嗯，看到了也会心里面荡起波澜，重拾起旧日习惯，会不会能够感受到旧日的快乐呢？emmmm，或许吧。不过会不会是一个有趣的尝试呢？我这样想着，在2020年的2月20日疫情期间，开启了
  • Linux 设备驱动之内核定时器 2020-02-20 Focus_Uphold
    该内核定时器的实现是基于低精度定时器实现，高精度定时器的实现代码更为复杂，将在其他章节做相应介绍structtimer_listgpio_trigger_time;//定义一个time_listprobe函数中添加如下：init_timer(&gpio_trigger_time);//初始化定时器gpio_trigger_time.expires=jiffies+HZ/100;//该种定时精度有限
  • 2020-02-20 - 草稿 娟儿_34bf
    教育的庆典，教育是有艺术氛围得过程，看聆听，读懂孩子，期待孩子超过我们，老师要喽卓，让孩子觉的他也是很棒的1。珍惜身边孩子发生的每一件事。深度学习，走向核心素养，深度学习，教师的引领下，学生全身心的融入学习。深度学习常态意识，老师会被AI代替，能者为师，不前进就会淘汰，加快前进得脚步，督促，前进，学习不是补短，而是扬长，发挥孩子长处。培养自学能力。激发热情，给学生赋能，教你是为了离开你以后还能学习
  • 2020-02-20 佐助
    你们肯定不知道我有多爱你们，在这个世界上最爱的人就是你们三了。哈哈，家庭地位最低的就是爸爸，他太难了，其次就是我，我只能怼我爸，我妈的家庭地位没有人可以撼动，老妹的地位又比我和我爸高，谁让她成绩好，还是高三生呢，惹不起她！昨天晚上老爸喝醉酒了，也是服了他，这个特殊时期，还和朋友喝酒，最惨的是他喝酒了跑去惹我妹，人家在上网课，写作业，他一直说话，也不知道说啥，老妹直接生气了，把他推出去把门锁了，哈哈
  • 2020-02-20 给孩子自己思考的空间 章贡1157杨晓娟
    “你站在桥上看风景，看风景人在楼上看你。明月装饰了你的窗子，你装饰了别人的梦。”每每想起卞之琳在《断章》里写到的这些诗句，我的心里都充盈着欢喜。欢喜风景处处有，只是取决于看风景人站立的角度。人生如此，课堂亦是如此。当我们用自己的挺拔站成一棵笔直的树，课堂就有了正直正气的教育；当我们用自己的智慧站成一棵灵秀青葱的树，课堂就有了卓约多姿的教育；当我们用自己的积淀站成一棵枝繁叶茂的树，课堂就有了内涵深蕴
  • 2020-02-20 zou咔咔
    今天要分享一些比较正能量的东西01因为没有很想追剧，所以我决定在b站上看想见你的一些解说视频，假装自己看过。我挑了一群小姐姐做的解说。那个时候剧还没有完结，但分析到最后她们感慨：其实一切都已经结局是什么已经不再重要了，希望在最后，他们都能得到救赎。当她们发现这个电视剧其实只是一个披着偶像剧外表的青春少年心理剧的时候，她们其实已经琢磨到了导演的初心。当正因为他们从初心去思考问题，所以正好把结局给说中
  • 2020-02-20 千红百艳
    待在家里的这段时间，有了时间，每天听的最多的就是疫情的报告，感动着医护人员的家国情怀，责任与担当，曾经一度，觉得自己每天忙忙碌碌，年前还感叹儿子放假学校没开学就有事回学校，年后确盼望孩子快点开学，怕影响他的学业，哎感叹，计划不如变化快，可能这只是人生路上的小插曲，国家要经历，我们的小家同样要经历，人们永远不知道意外和惊喜哪个先来！珍惜现在，不畏未来！外面忽然下起了雪，细细密密的雪花飘落大地，我抬着
  • 2020-02-20 不倒娃娃Judy
    这几天我做的几件事：疫情放假在家的这几天，其实有很多发生微妙变化的事情。但是，有一件意外之事，让我现在每天充满力量。虽然在家人眼中我没什么不一样，其实，自己知道波澜不惊的掩饰下全是小窃喜。这件事就是养成了早起的习惯！早起，这两个字，对于我这种从小到大都是晚起型的人来说一直都是闪烁着光芒，只可远观。也曾立下豪言壮语，明天必须早起，用过各种肤浅的方法。比如：设置18个闹钟、忍痛睡前不看手机、甚至手机放
  • 2020-02-20 王健_100a
    【诗90:17】愿主我们神的荣美归于我们身上。愿你坚立我们手所作的工；我们手所作的工，愿你坚立。解释：因为我们的日子屈指可数，所以我们希望自己的工作算数、有效和有成果。我们希望通过自己的工作看到神永恒的计划和荣耀。如果我们对今生今世不满，并抱怨一切不好的地方，请记住我们要看到工作成就的这种愿望是神放在我们心中的，但是我们的愿望只能在永恒中实现。应用：基督徒如何做主的工！难道就是为主全时间的奉献侍奉
  • 2020-02-20家有小女字悠然 悠悠我心_df9c
    王梓悠，字悠然，2019.1.18，我的小女儿，我家老大16岁，04年的，男孩，老二十一09年的，男孩，所以到了我家老三，呵呵，如果不是想要一个女孩，她也不能出生啊，我真的是做梦都想要一个女孩，一个花朵一样的女孩。其实我这个人还是有一个好的优点的，就是我会自动屏闭一些不愉快，所以我的悠悠一定是在天上挑妈妈的时候看到了我，然后义无反顾的来到我的肚子里的，她一定是老天对我的救赎，才会在我想要女孩的时候
  • 2020-02-20 樊汐
    人无法拒绝快乐，哪怕是沙雕的快乐疫情期间接了好几次社区电话，移动基站查人口真的牛批，以及，生活了二十多年终于知道是哪个社区管我了。。。下楼溜达看见路口设立的管控门房、街区封闭、逐车询问，才发现一个城市原来可以这么小，小到随时能监控每个人的位置。城市瘫痪，门市关闭，当公务员、教师、事业编的人们窃喜着带薪休假时，那些用业绩才能换银子生活下去的劳动者，正无比期待这次疫情能解除封锁、尽快结束。那天晚饭跟妈
  • “孤战春秋”路人局-2020-02-20 Loih落埃
    孤战春秋2020.02.20大师级神族！在星际争霸2战网游戏大厅中搜索“孤战春秋”，体验适合团队竞技的RTS游戏，我们是最后的指挥官，我们在战网等你！
  • 2020-02-20 HW12138
    想考上首师大教育专硕，首先，你得了解你的目标学校！首都师范大学建于1954年，办学历史可追溯至1905年成立的通州师范，是国家”双一流”建设高校、北京市与教育部“省部共建”高校。首都师范大学师资力量雄厚，拥有一支高水平的研究生导师队伍，现有博士生导师260余人，硕士生导师1000余人；首都师范大学高度重视研究生的培养质量，全面提升教学科研能力和培养水平，已步入“以创新为灵魂，以质量为主线”的新时期
  • 2020-02-20 _白ma措
    三毛经典语录大全。一、刻意去找的东西，往往是找不到的。天下万物的来和去，都有它的时间。——三毛二、一个人至少拥有一个梦想，有一个理由去坚强。心若没有栖息的地方，到哪里都是在流浪。——三毛三、在这个城市里，我相信一定会有那么一个人，想着同样的事情，怀着相似的频率，在某站寂寞的出口，安排好了与我相遇。——三毛三毛经典语录大全，发朋友圈很有格调四、我相信，上天不给我的，无论我十指怎样紧扣仍会走漏，给我的
  • 2020-02-20 岁月无言2019
    今天来单位上班了，以为挺早的，结果老谢已经去机关参加防疫督察了。坐下来，迫不及待的查看疫情。还好还好，今天又是双0，无新增无疑似。希望这样坚持14天，这样我们就可以摘下口罩，素面朝天，太渴望灿烂的阳光了。单位事情不多，整理一下昨天新装系统的电脑。昨天居然给我装的xp，感觉复古了很过。疫情当前，能用就行，等疫情结束以后再重新更换吧。最近说的最多的，无外乎是“等疫情结束以后”。直到今天，我依旧不能想象
  • 2020-02-20 西域社群
    念念皆是自己事事皆是自己人人皆是自己向内求的人，一切都是最好的安排。都是提升自己的通道。向外求的人，一切都满足不了自己的欲壑。继而就是——求不得一内一外，智慧开关所在。
  • 2020-02-20 larslee
    睿教通APP用户服务协议睿教通APP尊重并保护所有使用服务用户的个人隐私权。为了给您提供更准确、更有个性化的服务，睿教通APP会按照本用户服务协议的规定使用您的个人信息。但睿教通APP将以高度的勤勉、审慎义务对待这些信息。除本用户服务协议另有规定外，在未征得您事先许可的情况下，睿教通APP不会将这些信息对外披露或向第三方提供。睿教通APP会不时更新本用户服务协议。您在同意睿教通APP服务使用协议之
  • 2020-02-20 梦灵紫洛
    老天爷呀，我今天怎么忘写了呀？我今天早上八点的时候，起床了(→o←)中午睡了一小会儿，就开始上网课，上完网课已经是三点半了，我开始写作业，上了一个半小时的网课，写了一个半小时的作业，写完作业就五点了，因为六点还要上英语网课，所以我没有吃饭，和爸爸打了一会儿板羽球之后就快要开课了。晚上看了一会儿电视，然后就睡了，现在又想起来没有写，就赶紧起来了。
  • 阳光2020-02-20 群星璀璨总舵主
    【今日分享】#阳光#等到黑夜翻面之后会是新的白昼等到海啸退去之后只是潮起潮落——林俊杰《裂缝中的阳光》图片发自App人出生的时候，赤条条，简简单单，什么都没有；人死的时候，孤零零，寂寂寥寥，什么也抓不住，带不走。一切都是一种经历，很多人看不透，机关算尽、苦心孤诣，在利益的交织中身心疲惫。其实，人生真正需要的是一些简单的东西，例如，阳光、空气、健康和很好的睡眠。大部分人都生活在一种假象中，我们以为很
  • 2020-02-20 行走江湖有哪些说话处事的禁忌，读读看看。 若有依
    1.少卖萌，少装嫩，不要以为自己很可爱，别人只会觉得你傻x，特别是过了20岁。2.凡事平和一点，尽量少发脾气。3.不矫情不做作。4.大大方方，不卑不亢。说话直视人的眼睛，小动作不要太多。走路抬头挺胸双肩下沉目视前方。5.不要用力过猛，什么都是过犹不及。6.不该问的问题不要问，不该说的话不要说。7.别人没问你的建议就请乖乖闭嘴，人之患在于好为人师。8.不要讨好别人，少夸奖别人。因为你现在的定位是人缘
  • 2020-02-20 梦在长安
    那些我们羡慕的生活，很多是用长年克制和勤奋换来的。平坦的腹部，那是对食物的克制；苗条的身材，那是对懒惰的克制；平静的内心，那是对脾气暴躁的克制……为什么我们一定要克制，目的就是为了能够过想要的生活。不管向往的生活是什么样，都要拥有能够驾驭内心欲望的能力。不管想获得尘世间的成功，还是内心的幸福，都是需要通过克制让我们更加强大。
  • 2020-02-20 Dream_7199
    剪不断理还乱。就刚刚我一气之下挂了他视频。我们又在吵孩子的教育问题，真的，我还应该再要这个吗？我的心里大大的疑问。两个已经够多麻烦了，我们根本就是三观不符的人，大家想法不一样，又不能磨合，还有必要吗？我真的伤心透了，自己的孩子就不能自己带自己教育吗？一直埋怨我质疑他父母不会教好小孩。我从来没有当面说过什么，只是一直要求我的孩子我自己教自己带。这样有错？作为一个妈妈，而你作为父亲，乐意给你自己父母相
  • 2020-02-20时间记录 296b871d5cd0
    日程安排（1）7：00起床（2）8：00上课项目管理、虚拟现实（3）12：25下课，吃饭（4）13：30写代码然后去跑步吧，（5）15：15上课（6）16：50下课，吃饭（7）18：30-19：15自修，写代码（8）19：20-20：05自修，写代码（9）20：05-21：00洗澡+俯卧撑（10）21：00-22：00总结时间（11）22：00睡前看书等写代码：时时发布项目和服务外包项目时间记录（
  • 2020-02-20 智汇园111
    广东众智教育简介广东众智教育有限公司是一家专门为企业团队精神建设、青少年综合素质培养提供服务的培训机构，服务项目主要包括军事教育、拓展训练、户外运动和主题夏（冬）令营等。公司组织正规，纪律严明，专业成熟、与时俱进，成立以来始终致力于依托强大的教官团队、完善的培训方案、科学的军事手段、严密的组织实施，持续不断的输送正能量，连绵不绝地挖掘潜意识，把一个个团队打造成一支支激情澎湃、奋勇向前的“军队”，把
  • 2020-02-20 金宇灏A
    大家都在为抗疫一起做着努力，医生们护士们也是站在前线奋勇前进抗争疫情。治疗的人越来越多，我相信这一停我们一定能扛过去。让我们回归原来的正常生活。早日开学或早日工作，而我们能帮助国家和武汉的唯一只有待在家里面不出门。这样可以减少飞沫传染的几率。减少感染的人数。大家都做的很好。只要待在家里面不出门，我们相信一群很快会好的。我们大家一定能战胜疫情。我们对祖国的努力，祖国一定会早日康复，武汉一定会早日康复
  • 2020-02-20 天秤座的茉莉
    一场疫情，让我静下来不少，也更让我明白江山易改本性难移，也更明确自己想要的是什么，随着年龄增长，越来越怀念小时候，可能这就是初老的现象吧，早上好[太阳]
  • 2020-02-20 爱吃牛肉的钟同学
    新的篇章20202.20在这个看着对称实际不对称的日子里，我决定给自己的人生翻开一个新的篇章。其实这个决定是昨天晚上下的，但为什么选择在今天，也许是今天的日期数字能满足我那一点小小的仪式感吧..疫情警报还没解除，我就自己偷偷回了杭州，原因是想着早点回杭隔离7天等待公司的实习。想想这也是第一次自己一个人租房子自己在远方生活，以前虽然离家也远但也有宿舍同学，合租也是有着相熟的朋友，我是一个乐观主义者，
  • 2020-02-20 胡杨Sandy
    2010年2月20日星期四晴人活着到底是为了什么？我们在不断追求世俗生活中的成功，有车有房，有奢侈品，有金钱有地位，有权利，有不断努力而获得的世俗认知，我们被认为我们要努力学习各种社会的技能，不被社会淘汰，我们不断寻找，寻找各种商机，机遇或者任何可能获得名利的途径，去争，去抢，去拼搏，最后获得更多的金钱，地位，名誉，然后我们用这些钱，权，人脉等获得更多的钱权人脉，然后在此过程中偶尔的午后或者某一个
  • 2020-02-20学习感悟 阿婷小可爱
    《瑜伽经》阐述的第一条教义就是“控制心灵的波动就是瑜伽”，说通俗点就是少想，减少念头，专注，练习禅定。定，能产生智慧，解脱。这是传统上练习瑜伽的目的。我们现代人，工作压力大，娱乐多，信息量大，所以瑜伽又成了现代人最好的练习。瑜伽这个古老的修炼又成了现代社会的解药。梵音如何受到会员好评的因为我们教练要坚持练习瑜伽，呼吸，冥想，自己体会瑜伽精髓的益处，引导教育会员，这样坚持瑜伽，让会员朋友受益瑜伽。并
  • mysql主从数据同步 林鹤霄 mysql主从数据同步
    配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22  二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
  • oracle学习笔记 caoyong oracle
    1、ORACLE的安装    a>、ORACLE的版本    8i,9i :   i是internet    10g,11g : grid (网格)    12c : cloud (云计算)       b>、10g不支持win7 &
  • 数据库，SQL零基础入门 天子之骄 sql数据库入门基本术语
    数据库，SQL零基础入门        做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。          数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
  • pom.xml 一炮送你回车库 pom.xml
    1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
  • sql查地区省市县 3213213333332132 sqlmysql
    -- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
  • 关于监听器那些让人头疼的事 宝剑锋梅花香 画图板监听器鼠标监听器
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。       
  • JAVA的遍历MAP darkranger map
    Java Map遍历方式的选择 1. 阐述 　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 　　为了解遍历性能的真实差距，包括在遍历ke
  • POJ 2312 Battle City 优先多列+bfs aijuans 搜索
    来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
  • Hibernate与Jpa的关系，终于弄懂 avords javaHibernate数据库jpa
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
  • 酸爽的console.log bee1314 console
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
  • other operate 征客丶 OSosx
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一
  • 【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
    1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
  • ZooKeeper 入门 BlueSkator 中间件zk
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么 BreakingBad mysqlDate
    取得当前时间用 now() 就行。 在数据库中格式化时间 用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。 可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 4_JAVA+Oracle面试题(有答案) chenke oracle
    基础测试题 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
  • 新一代工作流系统设计目标 comsci 工作算法脚本
      用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 在这个设计中，最难的地方是系统根据什么来生成流
  • oracle 行链接与行迁移 daizj oracle行迁移
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
  • [JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop电子商务
    前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
  • 初三全学年难记忆单词 dcj3sjt126com englishword
    several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
  • sphinx实践 dcj3sjt126com sphinx
      安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server   yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
  • JPA之JPQL（三） frank1234 ormjpaJPQL
    1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public  void querySingleObject1() {     Query query = em.createQuery("sele
  • Remove Duplicates from Sorted Array II hcx2013 remove
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
  • Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装Mysql5.5 liuxingguome centos
    CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
  • 第14章 工具函数（下） onestopweb 函数
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • POJ 1050 SaraWon 二维数组子矩阵最大和
    POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思： 给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
  • [5]设计模式——单例模式 tsface java单例设计模式虚拟机
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点   安全的单例模式：     /* * @(#)Singleton.java 2014-8-1 * * Copyright 2014 XXXX, Inc. All rights reserved. */ package com.fiberhome.singleton;
  • Java8全新打造，英语学习supertool yangshangchuan javasuperword闭包java8函数式编程
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。   升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他