你的小红书笔记几点更新？


为什么你总是看到我在晚上6点多或者是中午的时候发公众号推送呢？因为每个创作平台都有自己的用户活跃和浏览的高峰期，像微信公众号一般都是在中午11点左右和晚上6点左右，这个时候微信用户点开订阅号消息和浏览的次数是最活跃的。

那么小红书呢？当然也是一样，也会有自己用户的活跃高峰期。

根据数据显示，小红书用户活跃的时间段在下午4点到6点、晚上8点到11点。但因为每个小红书博主的受众人群都是不一样的，这就跟我们之前说的一样，要根据自己的内容来确定用户画像和活跃时间。不同领域的博主内容不一样，受众人群在小红书活跃的时间也是不太一样的。

但是，还有一点也很重要的是，没找好笔记发布时间绝对不是数据效果不理想的借口。

虽然有时候我们的发布时间有可能会影响笔记数据，但这种影响并不一定是绝对的，也很有可能是你的笔记内容本身就不行。之前也有看到过群里的小伙伴反馈说，半夜一两点发布的笔记数据效果却反而很好。



 

（一位美妆博主的笔记，发布时间在6点左右）

 

其实说到底，还是我们笔记内容的问题。笔记内容好了，数据效果不会差，但如果能够选对好的时间来发布，那么效果一定还能够更好。

那么我们怎么才能确定适合自己的小红书更新时间呢？到底什么时候发内容效果才能最好呢？可以跟着下面的步骤来测试一下适合自己的更新时间：

1）确定粉丝画像

我们要做的第一步就是先要确定自己的粉丝画像，通过平常发的内容，了解自己的粉丝都是什么样的人，大概都是哪个群体，是年轻的上班族、有一定消费能力的都市白领还是收入不稳定的学生党，再根据这些来推导他们的日常生活习惯。

比如，白领的话，晚上八点多就是他们下班之后在家休息的时间，可能就会多看看小红书上的内容。像这类的内容平时也可以通过自己的评论多和粉丝交流沟通，多了解一下粉丝群体。

2）测试优化和总结

在通过明确粉丝画像，推导他们的日常习惯之后，就可以制定具体的时间节点来测试一下。

比如对于都市上班的女性上班族，一般来说中午休息时间12点左右以及晚上下班8点以后，可能浏览小红书的机会就比较高，选择这两个时间节点来发布笔记，测试并且记录发布一个小时、三个小时的具体笔记数据，也可以多测试几次，不断优化，之后再通过比较和分析具体的笔记数据和内容来选择适合自己的时间。

当然，可能一下子不准确，也可以多尝试几次。也有可能有些小伙伴不太确定到底自己的粉丝群体怎么样，可以测试哪些发布时间。

下面也收集了一些小红书博主数据，大致总结出了一些类目博主的常规更新时间，【需要种草的百度一下：于飞SEO，可以联系到我】可以给大家参考一下：

1. 美妆类博主：中午11点、下午6点左右

2. 学习类博主：上午8点左右、下午1点左右

3. 母婴类博主：晚上10点左右、上午10点左右

4. 穿搭类博主：晚上7点到10点

5. 美食类博主：下午5点到晚上8点

 



（一位美食博主的笔记数据）

 

观察这些数据，其实有些类目的博主更新时间还是很有规律和原因的。

像美食类目的博主选择在下午5点到8点更新，是因为这个时间段一般都是大家回到家开始做晚饭的时候，打开小红书就可以浏览一下各类美食的教程合集；

而一般妈妈们白天需要照顾孩子和日常工作，一般上小红书的时间就会稍晚一点，所以母婴类的博主也会选在晚上九点、十点这些时间来更新；

像穿搭类、美妆类这些内容针对的女性群体，一般都是上班族和学生党，就会选择晚上6点到8点这类时间来更新内容。

通过以上内容，也希望在笔记发布时间上为大家做一个参考，但如果觉得自己的笔记数据一直不够好，首先还是应该反思自己的内容问题。

当然，如果还有什么有关于小红书运营的问题，也可以在评论区留言，看到一定回复。

很多人可能听过试客小兵以及钱咖这个软件，但是很多人不知道试客小兵几点出任务以及钱咖软件是骗人的吗，今天baby教你学手赚为大家讲解一些这方面的经验和知识。

试客小兵几点出任务：
关于这个问题，baby教你学手赚可以肯定的告诉你，试客小兵任务更新时间不固定的，一般上午和下午都会有任务更新的， 但是大量的任务通常聚集在3-6点左右的，一般下午做任务的也比较多，有些时候不太容易抢任务，所以大家一定要多找一些平台操作才可以的。

试玩app的工作行吗：
因为很多人没哟接触过试玩app的工作，所以不知道试玩app的工作行吗，关于这个问题baby教你学手赚 可以肯定的告诉你还是很不错的，但是前提是要有方法的，目前来讲市面上有一些科技公司，专门研究 做这个试玩的，每个公司可能都有自己的一套赚钱体系的，还是很不错的。但是如果你是自己个人想要 在家全职做手机试玩app的，那么笔者还是不建议这样做的，因为手机试玩app如果没有方法的话，那么 每天也就只能赚个几十块的零花钱而已的，仅仅够自己的生活费的，所以尽量别全职去做哦！笔者自己 目前也不是全职做的。

试玩app哪些平台比较好：
关于这个问题baby教你学手赚想说好的平台太多了，如果你对这方面有兴趣，但是不知道什么平台好的，可以关注一下笔者的公众号：yaam77，公众浩里面有很多不错的试玩平台的，让大家用手机轻松日入50元以上吧。
钱咖软件是骗人的吗：
很多人可能没玩过钱咖这个软件，所以不知道钱咖软件是骗人的吗，关于这个问题，baby教你学手赚可以肯定的告诉你，不是骗人的，大家可以放心试玩的。而且钱咖这个试玩平台很多不错的，任务佣金可以，而且任务数量也是比较稳定的。

果试玩赚钱对手机有影响吗：

其实baby教你学手赚可以肯定的告诉你，没有什么影响的，因为试玩app通常就是下载，有些人可能担 心不安全或者不靠谱，这个很简单的，大家自己试试看就行了啊，实践出真知！

为什么baby教你学手赚告诉你没有什么影响呢？因为试玩app，任务完成之后，下载的app可以删除的， 这个并不占用你自己手机内存的，笔者现在的4s目前还在服役的状态中，很多年了，苹果手机确实很强 大的，当然安卓手机也很不错的。

手机试玩app抢不到任务：
有些人可能感觉刚开始试玩app的时候抢任务很简单的，每个平台上都有十几二十个任务供大家亲自下 载的，基本上不费吹灰之力即可抢到任务的，但是这些任务做完之后，然后慢慢的好像感觉抢不到什么 任务了，关于这个问题baby教你学手赚可以肯定的告诉你这属于正常现象的，因为刚开始平台任务多， 是因为自己操作的不熟练，所以每个平台都会有很多任务供你熟悉的，这些任务做完之后也就慢慢的熟 悉了，熟悉之后就开始自己抢任务了！有些人感觉抢不到任务也正常的， 因为试玩app做的人太多了， 任务少，做的人比较多，所以有些时候抢不到的，如果抢不到的话，那么可以多做一些平台就好了。

有兴趣的朋友记得关注一下公众号：yaam77  想要了解试客小兵的，可以查阅《微信上试客小兵是真的吗》

0 0/1 8-18 ? * 2-6

 

ExecutorService

java.util.concurrent

接口 ExecutorService

所有超级接口：

    Executor

所有已知子接口：

    ScheduledExecutorService

所有已知实现类：

    AbstractExecutorService, ScheduledThreadPoolExecutor, ThreadPoolExecutor
ExecutorService提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。

可以关闭 ExecutorService，这将导致其拒绝新任务。提供两个方法来关闭 ExecutorService。
shutdown()方法在终止前允许执行以前提交的任务，而 shutdownNow() 方法阻止等待任务的启动并试图停止当前正在执行的任务。在终止后，执行程序没有任务在执行，也没有任务在等待执行，并且无法提交新任务。应该关闭未使用的 ExecutorService以允许回收其资源。

通过创建并返回一个可用于取消执行和/或等待完成的 Future，方法submit扩展了基本方法 Executor.execute(java.lang.Runnable)。
方法 invokeAny 和 invokeAll 是批量执行的最常用形式，它们执行任务 collection，然后等待至少一个，

或全部任务完成（可使用 ExecutorCompletionService类来编写这些方法的自定义变体）。

Executors类为创建ExecutorService提供了便捷的工厂方法。
注意1:它只有一个直接实现类ThreadPoolExecutor和间接实现类ScheduledThreadPoolExecutor。

关于ThreadPoolExecutor的更多内容请参考《ThreadPoolExecutor》

关于ScheduledThreadPoolExecutor的更多内容请参考《ScheduledThreadPoolExecutor》

更多请查看原文：http://hubingforever.blog.163.com/blog/static/17104057920109544134947/
ThreadPoolExecutor几点使用建议



正文

先看一副图，描述了ThreadPoolExecutor的工作机制: 





整个ThreadPoolExecutor的任务处理有4步操作：

 

第一步，初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行

第二步，当提交的任务数超过了corePoolSize，就进入了第二步操作。会将当前的runable提交到一个block queue中

第三步，如果block queue是个有界队列，当队列满了之后就进入了第三步。如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务

第四步，如果第三步救急方案也无法处理了，就会走到第四步执行reject操作。

几点说明：(相信这些网上一搜一大把，我这里简单介绍下，为后面做一下铺垫)


block queue有以下几种实现：

1. ArrayBlockingQueue :  有界的数组队列

2. LinkedBlockingQueue : 可支持有界/无界的队列，使用链表实现

3. PriorityBlockingQueue : 优先队列，可以针对任务排序

4. SynchronousQueue : 队列长度为1的队列，和Array有点区别就是：client thread提交到block queue会是一个阻塞过程，直到有一个worker thread连接上来poll task。

RejectExecutionHandler是针对任务无法处理时的一些自保护处理：

1. Reject 直接抛出Reject exception

2. Discard 直接忽略该runnable，不可取

3. DiscardOldest 丢弃最早入队列的的任务

4. CallsRun 直接让原先的client thread做为worker线程，进行执行




容易被人忽略的点：

1.  pool threads启动后，以后的任务获取都会通过block queue中，获取堆积的runnable task.




所以建议： block
 size >= corePoolSize ，不然线程池就没任何意义

2.  corePoolSize 和 maximumPoolSize的区别， 和大家正常理解的数据库连接池不太一样。

  *  据dbcp pool为例，会有minIdle , maxActive配置。minIdle代表是常驻内存中的threads数量，maxActive代表是工作的最大线程数。

  *  这里的corePoolSize就是连接池的maxActive的概念，它没有minIdle的概念(每个线程可以设置keepAliveTime，超过多少时间多有任务后销毁线程，默认只会针对maximumPoolSize参数的线程生效，可以设置allowCoreThreadTimeOut=true，就可以对corePoolSize进行idle回收)。 

  * 这里的maximumPoolSize，是一种救急措施的第一层。当threadPoolExecutor的工作threads存在满负荷，并且block queue队列也满了，这时代表接近崩溃边缘。这时允许临时起一批threads，用来处理runnable，处理完后通过keepAliveTime进行调度回收。




所以建议：  maximumPoolSize
 >= corePoolSize =期望的最大线程数。 (我曾经配置了corePoolSize=1, maximumPoolSize=20, blockqueue为无界队列，最后就成了单线程工作的pool。典型的配置错误)




3. 善用blockqueue和reject组合. 这里要重点推荐下CallsRun的Rejected Handler，从字面意思就是让调用者自己来运行。

我们经常会在线上使用一些线程池做异步处理，比如我前面做的(业务层)异步并行加载技术分析和设计, 将原本串行的请求都变为了并行操作，但过多的并行会增加系统的负载(比如软中断，上下文切换)。所以肯定需要对线程池做一个size限制。但是为了引入异步操作后，避免因在block
 queue的等待时间过长，所以需要在队列满的时，执行一个callsRun的策略，并行的操作又转为一个串行处理，这样就可以保证尽量少的延迟影响。




所以建议：  RejectExecutionHandler
 = CallsRun ,  blockqueue size = 2 * poolSize (为啥是2倍poolSize，主要一个考虑就是瞬间高峰处理，允许一个thread等待一个runnable任务)

Btrace容量规划

再提供一个btrace脚本，分析线上的thread pool容量规划是否合理，可以运行时输出poolSize等一些数据。

 

 
import static com.sun.btrace.BTraceUtils.addToAggregation;
import static com.sun.btrace.BTraceUtils.field;
import static com.sun.btrace.BTraceUtils.get;
import static com.sun.btrace.BTraceUtils.newAggregation;
import static com.sun.btrace.BTraceUtils.newAggregationKey;
import static com.sun.btrace.BTraceUtils.printAggregation;
import static com.sun.btrace.BTraceUtils.println;
import static com.sun.btrace.BTraceUtils.str;
import static com.sun.btrace.BTraceUtils.strcat;

import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;

import com.sun.btrace.BTraceUtils;
import com.sun.btrace.aggregation.Aggregation;
import com.sun.btrace.aggregation.AggregationFunction;
import com.sun.btrace.aggregation.AggregationKey;
import com.sun.btrace.annotations.BTrace;
import com.sun.btrace.annotations.Kind;
import com.sun.btrace.annotations.Location;
import com.sun.btrace.annotations.OnEvent;
import com.sun.btrace.annotations.OnMethod;
import com.sun.btrace.annotations.OnTimer;
import com.sun.btrace.annotations.Self;

/**
 * 并行加载监控
 * 
 * @author jianghang 2011-4-7 下午10:59:53
 */
@BTrace
public class AsyncLoadTracer {

    private static AtomicInteger rejecctCount = BTraceUtils.newAtomicInteger(0);
    private static Aggregation   histogram    = newAggregation(AggregationFunction.QUANTIZE);
    private static Aggregation   average      = newAggregation(AggregationFunction.AVERAGE);
    private static Aggregation   max          = newAggregation(AggregationFunction.MAXIMUM);
    private static Aggregation   min          = newAggregation(AggregationFunction.MINIMUM);
    private static Aggregation   sum          = newAggregation(AggregationFunction.SUM);
    private static Aggregation   count        = newAggregation(AggregationFunction.COUNT);

    @OnMethod(clazz = "java.util.concurrent.ThreadPoolExecutor", method = "execute", location = @Location(value = Kind.ENTRY))
    public static void executeMonitor(@Self Object self) {
        Field poolSizeField = field("java.util.concurrent.ThreadPoolExecutor", "poolSize");
        Field largestPoolSizeField = field("java.util.concurrent.ThreadPoolExecutor", "largestPoolSize");
        Field workQueueField = field("java.util.concurrent.ThreadPoolExecutor", "workQueue");

        Field countField = field("java.util.concurrent.ArrayBlockingQueue", "count");
        int poolSize = (Integer) get(poolSizeField, self);
        int largestPoolSize = (Integer) get(largestPoolSizeField, self);
        int queueSize = (Integer) get(countField, get(workQueueField, self));

        println(strcat(strcat(strcat(strcat(strcat("poolSize : ", str(poolSize)), " largestPoolSize : "),
                                     str(largestPoolSize)), " queueSize : "), str(queueSize)));
    }

    @OnMethod(clazz = "java.util.concurrent.ThreadPoolExecutor", method = "reject", location = @Location(value = Kind.ENTRY))
    public static void rejectMonitor(@Self Object self) {
        String name = str(self);
        if (BTraceUtils.startsWith(name, "com.alibaba.pivot.common.asyncload.impl.pool.AsyncLoadThreadPool")) {
            BTraceUtils.incrementAndGet(rejecctCount);
        }
    }

    @OnTimer(1000)
    public static void rejectPrintln() {
        int reject = BTraceUtils.getAndSet(rejecctCount, 0);
        println(strcat("reject count in 1000 msec: ", str(reject)));
        AggregationKey key = newAggregationKey("rejectCount");
        addToAggregation(histogram, key, reject);
        addToAggregation(average, key, reject);
        addToAggregation(max, key, reject);
        addToAggregation(min, key, reject);
        addToAggregation(sum, key, reject);
        addToAggregation(count, key, reject);
    }

    @OnEvent
    public static void onEvent() {
        BTraceUtils.truncateAggregation(histogram, 10);
        println("---------------------------------------------");
        printAggregation("Count", count);
        printAggregation("Min", min);
        printAggregation("Max", max);
        printAggregation("Average", average);
        printAggregation("Sum", sum);
        printAggregation("Histogram", histogram);
        println("---------------------------------------------");
    }
}
 

运行结果：

 
poolSize : 1 , largestPoolSize = 10 , queueSize = 10
reject count in 1000 msec: 0

 

说明：

1. poolSize 代表为当前的线程数

2. largestPoolSize 代表为历史最大的线程数

3. queueSize 代表blockqueue的当前堆积的size

4. reject count 代表在1000ms内的被reject的数量




 

ExecutorService 建立多线程的步骤：



1。定义线程类

class Handler implements Runnable{

}

2。建立ExecutorService线程池

ExecutorService executorService = Executors.newCachedThreadPool();


或者


int cpuNums = Runtime.getRuntime().availableProcessors();

                //获取当前系统的CPU 数目

ExecutorService executorService =Executors.newFixedThreadPool(cpuNums * POOL_SIZE);

                //ExecutorService通常根据系统资源情况灵活定义线程池大小

3。调用线程池操作

循环操作，成为daemon,把新实例放入Executor池中

      while(true){

        executorService.execute(new Handler(socket)); 

           // class Handler implements Runnable{

        或者

        executorService.execute(createTask(i));

            //private static Runnable createTask(final int taskID)

      }


execute(Runnable对象)方法

其实就是对Runnable对象调用start()方法

（当然还有一些其他后台动作，比如队列，优先级，IDLE timeout，active激活等）


几种不同的ExecutorService线程池对象

1.newCachedThreadPool() 

-缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中

-缓存型池子通常用于执行一些生存期很短的异步型任务

 因此在一些面向连接的daemon型SERVER中用得不多。

-能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。

  注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。

2. newFixedThreadPool

-newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程

-其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子

-和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器

-从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:
fixed池线程数固定，并且是0秒IDLE（无IDLE）
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE  

3.ScheduledThreadPool

-调度型线程池

-这个池子里的线程可以按schedule依次delay执行，或周期执行

4.SingleThreadExecutor

-单例线程，任意时间池中只能有一个线程

-用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）


上面四种线程池，都使用Executor的缺省线程工厂建立线程，也可单独定义自己的线程工厂
下面是缺省线程工厂代码:

    static class DefaultThreadFactory implements ThreadFactory {

        static final AtomicInteger poolNumber = new AtomicInteger(1);

        final ThreadGroup group;

        final AtomicInteger threadNumber = new AtomicInteger(1);

        final String namePrefix;


        DefaultThreadFactory() {

            SecurityManager s = System.getSecurityManager();

            group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup();

          

            namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";

        }


        public Thread newThread(Runnable r) {

            Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);

            if (t.isDaemon())

                t.setDaemon(false);

            if (t.getPriority() != Thread.NORM_PRIORITY)

                t.setPriority(Thread.NORM_PRIORITY);

            return t;

        }

    }
也可自己定义ThreadFactory，加入建立池的参数中

 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {


Executor的execute()方法
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类（cache,fiexed,single三种池子都是调用它）的execute方法如下：

    public void execute(Runnable command) {

        if (command == null)

            throw new NullPointerException();

        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {

            if (runState == RUNNING && workQueue.offer(command)) {

                if (runState != RUNNING || poolSize == 0)

                    ensureQueuedTaskHandled(command);

            }

            else if (!addIfUnderMaximumPoolSize(command))

                reject(command); // is shutdown or saturated

        }

    }