GSON、LinkedTransferQueue、StringUtils_public static <t> t fromjson(string str, class<t> -优快云博客

Gson-Typetoken

public class JsonUtils {
    private static final Gson gson = new Gson();

    public static <T> T fromJson(String jsonStr, Class<T> clazz) {
        return gson.fromJson(jsonStr, clazz);
    }

    public static <T> String toJson(T t) {
        return gson.toJson(t);
    }
}

private static final Class headerType = new TypeToken<Map<String, String>>() {
}.getRawType();

//调用的时候
Map<String, String> headerMap = (Map<String, String>) JsonUtils.fromJson(header, headerType);

LinkedTransferQueue阻塞队列

LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，LinkedTransferQueue多了tryTransfer和transfer方法。

LinkedTransferQueue采用一种预占模式。意思就是消费者线程取元素时，如果队列不为空，则直接取走数据；若队列为空，那就生成一个节点（节点元素为null）入队，然后消费者线程被等待在这个节点上，后面生产者线程入队时发现有一个元素为null的节点，生产者线程就不入队了，直接就将元素填充到该节点，并唤醒该节点等待的线程，被唤醒的消费者线程取走元素，从调用的方法返回。我们称这种节点操作为“匹配”方式。

LinkedTransferQueue是ConcurrentLinkedQueue、SynchronousQueue（公平模式下转交元素）、LinkedBlockingQueue（阻塞Queue的基本方法）的超集。而且LinkedTransferQueue更好用，因为它不仅仅综合了这几个类的功能，同时也提供了更高效的实现。

简单用法介绍------------------------------------------------------------------------------------------------------

存：

put(); 放元素进去队列，注意队列是可以无限长的

add(); 同上

transfer(); 这个是重点，如果队列中有人发现有人在等，则直接给那个人（有一个参数waiter指定了在等的线程），如果没人在等，就放进队列

取：

poll(); 立即返回，如果没有元素就是空

take(); 如果没有元素，那就等

参考资料：https://www.cnblogs.com/rockman12352/p/3790245.html

StringUtils常用方法

public static boolean isEmpty(String str)：判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0

public static boolean isBlank(String str)：判断某字符串是否为空或长度为0或由空白符(whitespace) 构成

StringUtils.substringAfterLast(string1,string2 )：将string1中string2最后出现的位置向后截取。

 String uri="/forebuy"

 String method = StringUtils.substringAfterLast(uri,"/fore" );

 answer：method=="buy"

参考文章：https://www.cnblogs.com/guiblog/p/7986410.html

String.format("start %d > end %d", start, end)

Objects

Objects.isNull(x)    //equals  x==null
Objects.nonNull(...)  //equals x!=null

Predicate和Consumer

接口表示一个接受单个输入参数并且没有返回值的操作。不像其他函数式接口，Consumer接口期望执行带有副作用的操作（译者注：Consumer的操作可能会更改输入参数的内部状态）。

Consumer接口中有2个方法，有且只有一个声明为accept(T t)的方法，接收一个输入参数并且没有返回值。

Predicate和Consumer接口的test()和accept()方法都接受一个泛型参数。不同的是test()方法进行某些逻辑判断并返回一个boolean值，而accept()接受并改变某个对象的内部值。

参考文章：http://ifeve.com/predicate-and-consumer-interface-in-java-util-function-package-in-java-8/

LoadingCache

参考文章：https://www.cnblogs.com/licunzhi/p/8818838.html

Pair

参考文章：https://blog.youkuaiyun.com/neweastsun/article/details/80294811

线程命名

这点得反复强调。对正在运行的JVM进行线程转储（thread dump）或者调试时，线程池默认的命名机制是pool-N-thread-M，这里N是线程池的序号（每新创建一个线程池，这个N都会加一），而M是池里线程的序号。比方说，pool-2-thread-3指的是JVM生命周期中第二个线程池里的第三个线程。参考这里 Executors.defaultThreadFactory()] (https://docs.oracle.com/javase/8/docs/api/java/util/concurrent /Executors.html#defaultThreadFactory--)。这样的名字表述性不佳。由于JDK将命名机制都隐藏在 [ThreadFactory 里面，这使得要正确地命名线程得稍微费点工夫。所幸的是Guava提供了这么一个工具类：

import com.google.common.util.concurrent.ThreadFactoryBuilder;
 
final ThreadFactory threadFactory = new ThreadFactoryBuilder()
        .setNameFormat("Orders-%d")
        .setDaemon(true)
        .build();
final ExecutorService executorService = Executors.newFixedThreadPool(10, threadFactory);


workers = Executors.newSingleThreadExecutor(
                new ThreadFactoryBuilder().setNameFormat("kafka-data-transfer, %d").build());

参考文章：http://arcticfox9902.iteye.com/blog/1114440

LoadingCache

参考文章：https://www.jianshu.com/p/f4b99b70bd76

Java中RunTime.getRunTime().addShutdownHook用法

 Runtime.getRuntime().addShutdownHook(Thread hook);

这个方法的含义说明：这个方法的意思就是在jvm中增加一个关闭的钩子，当jvm关闭的时候，会执行系统中已经设置的所有通过方法addShutdownHook添加的钩子，当系统执行完这些钩子后，jvm才会关闭。所以这些钩子可以在jvm关闭的时候进行内存清理、对象销毁等操作。

参考文章：https://www.cnblogs.com/chasewade/p/3387423.html

Hase

参考资料：https://www.cnblogs.com/caiyisen/p/7424177.html

http://blog.51cto.com/xpleaf/2086957

AtomicReference 原子引用

赋值操作不是线程安全的。若想不用锁来实现，可以用AtomicReference<V>这个类，实现对象引用的原子更新。

使用场景：一个线程使用student对象，另一个线程负责定时读表，更新这个对象。那么就可以用AtomicReference这个类。java.util.concurrent.atomic.AtomicReference<V>
类的名字。
2.常用方法

java.util.concurrent.atomic.AtomicReference.AtomicReference(V initialValue)   //构造函数。

V java.util.concurrent.atomic.AtomicReference.get() //返回当前的引用。

boolean java.util.concurrent.atomic.AtomicReference.compareAndSet(V expect, V update)  //如果当前值与给定的expect相等，（注意是引用相等而不是equals()相等），更新为指定的update值。

V java.util.concurrent.atomic.AtomicReference.getAndSet(V newValue)  //原子地设为给定值并返回旧值。

void java.util.concurrent.atomic.AtomicReference.set(V newValue)  //注意此方法不是原子的

参考文章： https://blog.youkuaiyun.com/chuchus/article/details/50801993

Log4j的使用：https://www.cnblogs.com/deng-cc/p/6739419.html

FastDateFormat使用

private static final FastDateFormat gcDateFormat = FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    private static final FastDateFormat minuteFormat = FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm");

//调用写入时间，得到long类型
public static long parseDate(String date) {
        try {
            return gcDateFormat.parse(date).getTime();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

LOG4J和Predicate和Consumer练习。