Arthas教你秒解GPU、内存、接口问题！提升排查效率轻松搞定！

# github下载
wget https://alibaba.github.io/arthas/arthas-boot.jar
# 或者 Gitee 下载
wget https://arthas.gitee.io/arthas-boot.jar
# 打印帮助信息
java -jar arthas-boot.jar -h

# 运行方式1，先运行，在选择 Java 进程 PID
java -jar arthas-boot.jar
# 选择进程(输入[]内编号(不是PID)回车)
[INFO] arthas-boot version: 3.5.0
[INFO] Found existing java process, please choose one and hit RETURN.
* [1]: 24480 com.Arthas
  [2]: 20520 com.jay.demos.ArthasTest
  [3]: 16200 org.jetbrains.jps.cmdline.Launcher
  [4]: 21032 org.jetbrains.idea.maven.server.RemoteMavenServer

# 运行方式2，运行时选择 Java 进程 PID
java -jar arthas-boot.jar [PID]

import java.util.HashSet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * <p>
 * Arthas Demo
 * 公众号：码农飞哥
 *
 * @Author 码农飞哥
 */

public class ArthasTest {
	
	private static HashSet hashSet = new HashSet();
	/**
	 * 线程池，大小1
	 */
	private static ExecutorService executorService = Executors.newFixedThreadPool(1);

	public static void main(String[] args) {
		// 模拟 CPU 过高
		cpu();
		// 模拟线程阻塞
		thread();
		// 模拟线程死锁
		deadThread();
		// 不断的向 hashSet 集合增加数据
		addHashSetThread();
	}

	/**
	 * 不断的向 hashSet 集合添加数据
	 */
	public static void addHashSetThread() {
		// 初始化常量
		new Thread(() -> {
			int count = 0;
			while (true) {
				try {
					hashSet.add("count" + count);
					Thread.sleep(10000);
					count++;
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}

	public static void cpu() {
		cpuHigh();
		cpuNormal();
	}

	/**
	 * 极度消耗CPU的线程
	 */
	private static void cpuHigh() {
		Thread thread = new Thread(() -> {
			while (true) {
				System.out.println("极度消耗CPU的线程，任务死循环，cpu start 100");
			}
		});
		// 添加到线程
		executorService.submit(thread);
	}

	/**
	 * 普通消耗CPU的线程
	 */
	private static void cpuNormal() {
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				while (true) {
					System.out.println("普通消耗CPU的线程，任务睡眠3000毫秒，死循环，cpu start");
					try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
	}

	/**
	 * 模拟线程阻塞,向已经满了的线程池提交线程
	 */
	private static void thread() {
		Thread thread = new Thread(() -> {
			while (true) {
				System.out.println("模拟线程阻塞，thread start");
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		// 添加到线程
		executorService.submit(thread);
	}

	/**
	 * 死锁
	 */
	private static void deadThread() {
		/** 创建资源 */
		Object resourceA = new Object();
		Object resourceB = new Object();
		// 创建线程
		Thread threadA = new Thread(() -> {
			synchronized (resourceA) {
				System.out.println(Thread.currentThread() + " get ResourceA");
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread() + "waiting get resourceB");
				synchronized (resourceB) {
					System.out.println(Thread.currentThread() + " get resourceB");
				}
			}
		});

		Thread threadB = new Thread(() -> {
			synchronized (resourceB) {
				System.out.println(Thread.currentThread() + " get ResourceB");
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread() + "waiting get resourceA");
				synchronized (resourceA) {
					System.out.println(Thread.currentThread() + " get resourceA");
				}
			}
		});
		threadA.start();
		threadB.start();
	}
}

	/**
	 * 死锁
	 */
	private static void deadThread() {
		/** 创建资源 */
		Object resourceA = new Object();
		Object resourceB = new Object();
		// 创建线程
		Thread threadA = new Thread(() -> {
			synchronized (resourceA) {
				System.out.println(Thread.currentThread() + " get ResourceA");
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread() + "waiting get resourceB");
				synchronized (resourceB) {
					System.out.println(Thread.currentThread() + " get resourceB");
				}
			}
		});

		Thread threadB = new Thread(() -> {
			synchronized (resourceB) {
				System.out.println(Thread.currentThread() + " get ResourceB");
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread() + "waiting get resourceA");
				synchronized (resourceA) {
					System.out.println(Thread.currentThread() + " get resourceA");
				}
			}
		});
		threadA.start();
		threadB.start();
	}

import java.util.HashMap;

@RestController
@Slf4j
public class UserController {

	@Autowired
	private UserServiceImpl userService;

	@GetMapping(value = "/user")
	public HashMap<String, Object> getUser(Integer uid) throws Exception {
		log.info("------模拟用户查询，uid={}----", uid);
		// 模拟用户查询
		userService.get(uid);
		HashMap<String, Object> hashMap = new HashMap<>();
		hashMap.put("uid", uid);
		hashMap.put("name", "name" + uid);
		return hashMap;
	}
}

package com.jay.demos.web;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class UserServiceImpl {

	public void get(Integer uid) throws Exception {
		check(uid);
		service(uid);
		redis(uid);
		mysql(uid);
	}

	public void service(Integer uid) throws Exception {
		int count = 0;
		for (int i = 0; i < 10; i++) {
			count += i;
		}
		log.info("service  end {}", count);
	}

	public void redis(Integer uid) throws Exception {
		int count = 0;
		for (int i = 0; i < 10000; i++) {
			count += i;
		}
		log.info("redis  end {}", count);
	}

	public void mysql(Integer uid) throws Exception {
		long count = 0;
		for (int i = 0; i < 10000000; i++) {
			count += i;
		}
		log.info("mysql end {}", count);
	}

	public boolean check(Integer uid) throws Exception {
		if (uid == null || uid < 0) {
			log.error("uid不正确，uid:{}", uid);
			throw new Exception("uid不正确");
		}
		return true;
	}
}