学习记录(待整理

spring的ioc https://javadoop.com/post/spring-ioc
spring的bean钩子 https://www.jianshu.com/p/a90a3e617ba6
java的hashset https://blog.csdn.net/guoweimelon/article/details/50804799?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight
java的lock补充 https://www.cnblogs.com/dolphin0520/p/3923167.html
常用注解 https://blog.csdn.net/yamadeee/article/details/80381092
c执行 编译汇编 https://www.cnblogs.com/mhq-martin/p/11898245.html
rxjs图解 https://rxmarbles.com/
章宜春 nginx http://openresty.org/download/agentzh-nginx-tutorials-zhcn.html
java的通配符 https://blog.csdn.net/a_finder/article/details/102766113
rocketmq ：起步，基础概念https://blog.csdn.net/weixin_40533111/article/details/84451096
作为顺序消费https://blog.csdn.net/hosaos/article/details/90675978
常用命令 https://www.cnblogs.com/gmq-sh/p/6232633.html
extend的作为生产者，super作为消费者
java的copyonwritearraylist https://www.jianshu.com/p/9b6a4d0b94ac
java多线程 http://concurrent.redspider.group/article/01/2.html
java的原子操作和双重锁检查
Object.wait https://blog.csdn.net/hemeinvyiqiluoben/article/details/82990817
Thread.join原理(wait-notify)简洁版 https://blog.csdn.net/u010983881/article/details/80257703
Thread.join的方法实习调用wait 如果省缺this，默认是当前实例而操作当前线程实例所在的线程(即调用线程，所以说join会把调用线程挂起。
当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行。
解释：

例子：

package pair1;
// previousThread.join时，让路给引用实例，wait的是currentThread
public class ThreadJoinTest extends Thread{
    int i;
    Thread previousThread; //上一个线程
    public ThreadJoinTest(Thread previousThread,int i){
        this.previousThread=previousThread;
        this.i=i;
    }
    @Override
    public void run() {
        try {
            //调用上一个线程的join方法，大家可以自己演示的时候可以把这行代码注释掉
            System.out.println("join====before print"+i+previousThread.getName());
            previousThread.join();
//            System.out.println("join====after print"+i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("num:"+i);
    }
    public static void main(String[] args) {
        Thread previousThread=Thread.currentThread();
        for(int i=0;i<10;i++){
            ThreadJoinTest joinDemo=new ThreadJoinTest(previousThread,i);
            System.out.println("start=====before print"+i);
            joinDemo.start();
            System.out.println("start=====after print"+i);
            previousThread=joinDemo;
        }
    }
}

futuretask https://blog.csdn.net/qq_39654841/article/details/90631

//FutureTask 自定义Callable
这里调用submit方法是没有返回值的。这里实际上是调用的
submit(Runnable task)方法，而Callable的Demo，调用的是submit(Callable<T> task)方法。
然后，这里是使用FutureTask直接取get取值，而上面的Demo是通过submit方法返回的Future去取值。
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        FutureTask<Integer> futureTask = new FutureTask<>(new Task());
        //这边只执行，使用原对象来get
        executor.submit(futureTask);
        System.out.println(futureTask.get());
    }
}
//Callable 自定义Callable，与上面一样
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        // 注意调用get方法会阻塞当前线程，直到得到结果。
        // 所以实际编码中建议使用可以设置超时时间的重载get方法。
        System.out.println(result.get()); 
    }
}

守护线程 https://www.cnblogs.com/quanxiaoha/p/10731361.html 守护进程是为了让jvm结束(main线程结束后)，线程不要在后台继续执行便于被GC回收。
aspectj的execute

• modifers-pattern：方法的修饰符，支持通配符，可以省略,一般省略
• return-type-pattern ；方法返回值类型，必写可以使用通配符*，表示所有返回值类型
  
• declaring-type-pattern：类路径。可以省略表示所有类。可以使用通配符。 com.example.dao.User* //表示 匹配com.example.dao包下，所有以User开头的类，其中.代表包下所有子类，..代表包下所有(子孙类)
• method-name: 方法名，必写。可以使用通配符*，表示所有方法。
  
• param-pattern：方法参数，必写。
  • 使用通配符* ，表示任意一个参数类型。
  • 使用通配符==…==，表示零个或多个任意类型的参数。
    (*,String)，匹配两个参数的方法。表示第一个参数类型任意，第二个必须为String类型。
    (..)，表示任意（个数、类型）参数
• throws-pattern：方法抛出异常，可以省略

forkjoin详细 https://www.jianshu.com/p/4e41727f8053 https://www.jianshu.com/p/f777abb7b251
best https://www.cnblogs.com/cjsblog/p/9078341.html

package pair1;
import java.util.Objects;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
/**
   可以来学习递归的分治
 * 计算1+2+3+...+n的值
 * 使用同步执行的方式
 *
 * @author yuhao.wang3
 * @since 2019/6/25 17:07
 */
public class ForkJoinCountTask extends RecursiveTask<Long> {
    /**
     * 阀值
     */
    private int threshold = 10;
    /**
     * 任务的开始值
     */
    private long start;
    /**
     * 任务的结束值
     */
    private long end;
    public ForkJoinCountTask(long start, long end) {
        this.start = start;
        this.end = end;
    }
    @Override
    protected Long compute() {
        if (end - start <= threshold) {
            long count = 0;
            for (int i = 0; i <= end - start; i++) {
                count = count + start + i;
            }
            System.out.println(String.format("arg: %s, count: %d","count", count));
            return count;
        } else {
            // 如果任务大于阈值，就分裂成三个子任务计算
            long slip = (end - start) / 3;
            ForkJoinCountTask oneTask = new ForkJoinCountTask(start, start + slip);
            ForkJoinCountTask twoTask = new ForkJoinCountTask(start + slip + 1, start + slip * 2);
            ForkJoinCountTask threeTask = new ForkJoinCountTask(start + slip * 2 + 1, end);
            // 提交子任务到框架去执行
            invokeAll(oneTask, twoTask, threeTask);
            // 等待子任务执行完，得到其结果，并合并子任务
            return oneTask.join() + twoTask.join() + threeTask.join();
        }
    }
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        // 生成一个计算任务，负责计算1+2+3+n
        ForkJoinCountTask countTask = new ForkJoinCountTask(1, 1000000);
        // 执行一个任务（同步执行，任务会阻塞在这里直到任务执行完成）
        pool.invoke(countTask);
        // 异常检查
        if (countTask.isCompletedAbnormally()) {
            Throwable throwable = countTask.getException();
            if (Objects.nonNull(throwable)) {
                System.out.println(throwable.getMessage());
            }
        }
        // join方法是一个阻塞方法，会等待任务执行完成
        System.out.println("计算为：" + countTask.join() + ", 耗时：" + (System.currentTimeMillis() - start) + "毫秒");
    }
}