-Xms100m -Xmx100m -XX:+UseSerialGC

package com.hlj.jvm.JvmBin.JvmJconsole;

/**
 * @Description JVM Jsoncole内存页 测试
 * @Author HealerJean
 * @Date 2018/4/10  下午5:35.
 */

import java.util.ArrayList;
import java.util.List;

 class JvmJconsole {

    /**
     * 内存占位符对象，一个OOMObject大约占64K
     */
    static class OOMObject {
        public byte[] placeholder = new byte[64 * 1024];
    }

    public static void fillHeap(int num) throws InterruptedException {
        List<OOMObject> list = new ArrayList<OOMObject>();
        for (int i = 0; i < num; i++) {
            // 稍作延时，令监视曲线的变化更加明显
            Thread.sleep(50);
            list.add(new OOMObject());
        }
        System.gc();
    }

    public static void main(String[] args) throws Exception {
        fillHeap(1000);
    }

}

package com.hlj.jvm.JvmBin.JvmJconsole;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Description 线程死循环和wait演示
 * @Author HealerJean
 * @Date 2018/4/10  下午6:52.
 */

public class JConsoleThreadWhileTest {
    /**
     * 线程一直跑while
     */
    public static void createBusyThread() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 状态: RUNNABLE 会在空循环上用尽全部执行时间直到线程切换，这种等待会消耗较多的CPU资源
                while (true) {

                }
            }
        }, "testBusyThread");
        thread.start();
    }

    /**
     * 锁等待测试
     *
     * @param lock
     */
    public static void createLockThread(final Object lock) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        // 线程等待着lock对象的notify或notifyAll方法的出现，线程这时间处于waiting状态，在被唤醒前不会被分配执行时间。
                        // 处理活锁状态，只要lock对象的notify或notifyAll方法出现，这个线程便能激活断续执行，
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "testLockThread");
        thread.start();
    }


    public static void main(String[] args) throws IOException, InterruptedException {
        // 控制台输入
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        br.readLine();
        createBusyThread();// 线程一直跑while
        br.readLine();
        Object obj = new Object();
        createLockThread(obj);// 锁等待测试
        Thread.sleep(10000000);
    }
}

package com.hlj.jvm.JvmBin.JvmJconsole;

/**
 * @Description 线程监控测试,死锁测试
 * @Author HealerJean
 * @Date 2018/4/10  下午7:20.
 */
public class JConsoleThreadTest {

    static class synRun implements Runnable {
        int a;
        int b;

        public synRun(int a, int b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public void run() {
            // Integer.valueOf(a) 会换存-128~127的数字，实际就返回了2和3两个对象
            synchronized (Integer.valueOf(a)) {
                // 假如在两个synchronized之间发生了线程切换，那就会出现线程a等待线程b的(Integer.valueOf(b))对象，
                // 而线程b又等待线程a的(Integer.valueOf(a))的对象，结果都跑不下去了，线程卡住，都等不了对方释放锁了
                synchronized (Integer.valueOf(b)) {
                    System.out.println(a + " + " + b + "=" + (a + b));
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(30000);// 30秒，有空余时间来启动,jconsole,并链接这个java进程
        System.out.println("start------");
        // 200个线程
        for (int i = 0; i < 100; i++) {
            new Thread(new synRun(2, 3)).start();
            new Thread(new synRun(3, 2)).start();
        }
        System.out.println("end------");
        Thread.sleep(10000000);// 一直停顿，方便查看数据

    }

}