public class Test {

    public static void main(String[] args) {
        Map<String, NodeProvider<Node>> map = new HashMap<>();
        map.put("ik", TestInner::getNode);

        System.out.println(map.get("ik").get("name", 1).getName());
        System.out.println(map.get("ik").get("name", 200).getAge());

    }
}

interface NodeProvider<T> {
    T get(String name, int age);
}

class Node {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class TestInner {
    public static Node getNode(String name, int age) {
        Node node = new Node();
        node.setAge(age);
        node.setName(name);

        return node;
    }
}

public class Singleton  {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton(){}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

/**
 * 懒汉式-双重检查
 */
public class SingletonLazy {
    private static SingletonLazy instance = null;

    private SingletonLazy() {
    }

    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

/**
 * 懒汉式-内部类
 */
public class SingletonLazy1 {


    private SingletonLazy1() {
    }

    private static class InnerSingleton {
        private final static SingletonLazy1 instance = new SingletonLazy1();
    }


    public static SingletonLazy1 getInstance() {

        return InnerSingleton.instance;
    }

    public static void helloworld() {
        System.out.println("hello lazy singleton.");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException{
        SingletonLazy1.helloworld();
        Object lock = new Object();
        synchronized (lock) {
            lock.wait(1000);
        }
        System.out.println("分割线---------------");
        System.out.println(SingletonLazy1.getInstance());
    }
}

输出结果：
[Loaded sun.nio.cs.US_ASCII$Decoder from /Library/Java/JavaVirtualMachines/jdk1.8.0_162.jdk/Contents/Home/jre/lib/rt.jar]
分割线---------------
[Loaded sun.misc.VMSupport from /Library/Java/JavaVirtualMachines/jdk1.8.0_162.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded com.wsy.learn.designmodel.SingletonLazy1$InnerSingleton from file:/Users/wangsiyuan1/workspace/springtest/target/classes/]
com.wsy.learn.designmodel.SingletonLazy1@27716f4

/**
 * 用阻塞队列实现生产-消费者模式
 */
public class Productor {
    static LinkedBlockingQueue<Integer> blockQueue = new LinkedBlockingQueue<>(10);

    void provide() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            blockQueue.offer(i);
            System.out.println("生产:" + i);
            Thread.sleep(100);
        }
    }
}

/**
 * 基于阻塞队列消费者
 */
public class Consumer {
    void cusume() throws InterruptedException {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("消费:" + Productor.blockQueue.take());
        }
    }
}

static void test0() {
    //创建生产者
    Productor productor = new Productor();
    //创建消费者
    Consumer consumer = new Consumer();
    Thread cusumerThread = new Thread(() -> {
        try {
            consumer.cusume();
        } catch (Exception e) {

        }

    });
    cusumerThread.start();

    try {
        productor.provide();

        cusumerThread.interrupt();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出：
生产:0
消费:0
生产:1
消费:1
生产:2
消费:2
生产:3
消费:3
生产:4
消费:4
生产:5
消费:5
生产:6
消费:6
生产:7
消费:7
消费:8
生产:8
生产:9
消费:9

/**
* 自己实现的简单的阻塞队列
*/
public class MyBlockQueue<E> {
    private LinkedList<E> queue = new LinkedList<>();
    //第一种实现方式，采用了Object wait和notify的方式
    private Object lock = new Object();
	//第二种实现方法，采用了ReentrantLock获取Condition，通过condition await和signal方式实现
    private ReentrantLock reentrantLock = new ReentrantLock();
    Condition con = reentrantLock.newCondition();

    void offer(E e) {
        queue.offer(e);
        synchronized (lock) {
            lock.notifyAll();
        }
    }

    E take() throws InterruptedException {
        if (queue.size() == 0) {
            synchronized (lock) {
                lock.wait();
            }
        }
        return queue.poll();
    }

    void offer1(E e) throws InterruptedException {

        try {
            reentrantLock.lockInterruptibly();
            queue.offer(e);
            con.signalAll();

        } finally {
            reentrantLock.unlock();
        }
    }

    E take1() throws InterruptedException {
        if (queue.size() == 0) {
            try {
                reentrantLock.lockInterruptibly();
                con.await();

            } finally {
                reentrantLock.unlock();
            }
        }
        return queue.poll();
    }
}

static void testInterrupt0()  Exception {
    int i = 0;
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("loop" + i++);
        if(i == 10) {
            Thread.currentThread().interrupt();
        }
    }
    //echo true
    System.out.println(Thread.currentThread().isInterrupted());
    //echo true
    System.out.println(Thread.currentThread().interrupted());
    //echo false
    System.out.println(Thread.currentThread().isInterrupted());
}

public class MyThread extends Thread {
    private Object lock;
    private String name;

    public MyThread(Object lock, String name) {
        this.lock = lock;
        this.name = name;
    }

    @Override
    public void run() {
        synchronized (lock) {
            try {
                System.out.println(name + " get lock,interrupt =" + Thread.currentThread().isInterrupted());

                lock.wait();

                //Thread.sleep(2000);
            } catch (InterruptedException e) {
                System.out.println(name + " is interrupt. notify all interrupt =" + Thread.currentThread().isInterrupted());
                lock.notifyAll();
            }
            System.out.println(name + ":notified...");
        }
    }
}

static void testNotify() throws Exception {
    MyThread t1 = new MyThread(lock, "t1");
    MyThread t2 = new MyThread(lock, "t2");

    Thread thread1 = new Thread(t1);
    Thread thread2 = new Thread(t2);

    thread1.start();
    thread2.start();

    Thread.sleep(1000);
    long startTime = System.currentTimeMillis();
    synchronized (lock) {
        System.out.println("main get lock");
        lock.notifyAll();
    }

    thread1.join();
    thread2.join();
    long endTime = System.currentTimeMillis();

    System.out.println("notify lock.time =" + (endTime - startTime));
}

public interface Hello {
    void sayHello(String str);
}

public final class HelloImpl implements Hello {
    private int[] array;

    public HelloImpl() {
        this.array = new int[1024*10];
    }

    @Override
    public void sayHello(String str) {
        System.out.println("hello " + str);
    }
}

public class LogInvocationHandler implements InvocationHandler {
    private Hello hello;

    public LogInvocationHandler(Hello hello) {
        this.hello = hello;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("sayHello".equals(method.getName())) {
            System.out.println("You said: " + Arrays.toString(args));
        }
        return method.invoke(hello, args);
    }


    public static void main(String[] args) {
        Object proxy = Proxy.newProxyInstance(LogInvocationHandler.class.getClassLoader(), // 1. 类加载器
                new Class<?>[]{Hello.class}, // 2. 代理需要实现的接口，可以有多个
                new LogInvocationHandler(new HelloImpl()));// 3. 方法调用的实际处理者

        Hello hello = (Hello) proxy;
        hello.sayHello("world");
        System.out.println(hello);
    }
}

ClassFile { 
    u4 magic; 
    u2 minor_version; 
    u2 major_version; 
    u2 constant_pool_count; 
    cp_info constant_pool[constant_pool_count-1]; 
    u2 access_flags; 
    u2 this_class; 
    u2 super_class; 
    u2 interfaces_count; 
    u2 interfaces[interfaces_count]; 
    u2 fields_count; 
    field_info fields[fields_count]; 
    u2 methods_count; 
    method_info methods[methods_count]; 
    u2 attributes_count; 
    attribute_info attributes[attributes_count]; 
}

magic： 作为一个魔数，确定这个文件是否是一个能被虚拟机接受的class文件，值固定为0xCAFEBABE。
minor_version，major_version：分别表示class文件的副，主版本号，不同版本的虚拟机实现支持的Class文件版本号不同。
constant_pool_count：常量池计数器，constant_pool_count的值等于常量池表中的成员数加1。
constant_pool：常量池，constant_pool是一种表结构，包含class文件结构及其子结构中引用的所有字符常量、类或接口名、字段名和其他常量。
access_flags：access_flags是一种访问标志，表示这个类或者接口的访问权限及属性，包括有ACC_PUBLIC，ACC_FINAL，ACC_SUPER等等。
this_class：类索引，指向常量池表中项的一个索引。
super_class：父类索引，这个值必须为0或者是对常量池中项的一个有效索引值，如果为0，表示这个class只能是Object类，只有它是唯一没有父类的类。
interfaces_count：接口计算器，表示当前类或者接口的直接父接口数量。
interfaces[]：接口表，里面的每个成员的值必须是一个对常量池表中项的一个有效索引值。
fields_count：字段计算器，表示当前class文件中fields表的成员个数，每个成员都是一个field_info。
fields：字段表，每个成员都是一个完整的fields_info结构，表示当前类或接口中某个字段的完整描述，不包括父类或父接口的部分。
methods_count：方法计数器，表示当前class文件methos表的成员个数。
methods：方法表，每个成员都是一个完整的method_info结构，可以表示类或接口中定义的所有方法，包括实例方法，类方法，以及类或接口初始化方法。
attributes_count：属性表，其中是每一个attribute_info，包含以下这些属性，InnerClasses，EnclosingMethod，Synthetic，Signature，Annonation等。

/**
 * 动态代理不能是final类
 * 如果是final类，会抛出异常：java.lang.IllegalArgumentException: Cannot subclass final class com.wsy.learn.jvm.autoproxy.cglib.HelloConcrete
 */
public class HelloConcrete {
    /**
     * 注意，此处如果定义的是final方法，则不会进入intercept方法进行方法增强
     * @param str
     * @return
     */
    public final String sayHello(String str) {
        return "HelloConcrete: " + str;
    }
}

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("You said: " + Arrays.toString(args));
        return proxy.invokeSuper(obj, args);
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(HelloConcrete.class);
        enhancer.setCallback(new MyMethodInterceptor());

        HelloConcrete hello = (HelloConcrete)enhancer.create();
        System.out.println(hello.sayHello("I love you!"));
    }
}

-XX:PermSize
方法区初始大小
-XX:MaxPermSize
方法区最大大小
超过这个值将会抛出OutOfMemoryError异常:java.lang.OutOfMemoryError: PermGen

  static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    ...
}