json复制代码{
    "timestamp": "2021-07-12T07:05:29.885+00:00",
    "status": 404,
    "error": "Not Found",
    "message": "No message available",
    "path": "/m1ain.html"
}

java复制代码@Bean
public ErrorPageCustomizer errorPageCustomizer(DispatcherServletPath dispatcherServletPath) {
    return new ErrorPageCustomizer(this.serverProperties, dispatcherServletPath);
}

java复制代码@Override
public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
    //将请求转发到 /errror（this.properties.getError().getPath()）上
    ErrorPage errorPage = new ErrorPage(this.dispatcherServletPath.getRelativePath(this.properties.getError().getPath()));
    // 注册错误页面
    errorPageRegistry.addErrorPages(errorPage);
}

java复制代码@Bean
@ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
public BasicErrorController basicErrorController(ErrorAttributes errorAttributes,
                                                 ObjectProvider<ErrorViewResolver> errorViewResolvers) {
    return new BasicErrorController(errorAttributes, this.serverProperties.getError(),
            errorViewResolvers.orderedStream().collect(Collectors.toList()));
}

java复制代码//BasicErrorController 用于处理 “/error” 请求
@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
    ......
    /**
     * 该方法用于处理浏览器客户端的请求发生的异常
     * 生成 html 页面来展示异常信息
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
    public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
        //获取错误状态码
        HttpStatus status = getStatus(request);
        //getErrorAttributes 根据错误信息来封装一些 model 数据，用于页面显示
        Map<String, Object> model = Collections
                .unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
        //为响应对象设置错误状态码
        response.setStatus(status.value());
        //调用 resolveErrorView() 方法，使用错误视图解析器生成 ModelAndView 对象（包含错误页面地址和页面内容）
        ModelAndView modelAndView = resolveErrorView(request, response, status, model);
        return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
    }

    /**
     * 该方法用于处理机器客户端的请求发生的错误
     * 产生 JSON 格式的数据展示错误信息
     * @param request
     * @return
     */
    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        HttpStatus status = getStatus(request);
        if (status == HttpStatus.NO_CONTENT) {
            return new ResponseEntity<>(status);
        }
        Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));
        return new ResponseEntity<>(body, status);
    }
    ......
}

scss复制代码Spring Boot 通过 BasicErrorController 进行统一的错误处理（例如默认的“/error”请求）。Spring Boot 会自动识别发出请求的客户端的类型（浏览器客户端或机器客户端），并根据客户端类型，将请求分别交给 errorHtml() 和 error() 方法进行处理。

java复制代码protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status,
                                        Map<String, Object> model) {
    //获取容器中的所有的错误视图解析器来处理该异常信息
    for (ErrorViewResolver resolver : this.errorViewResolvers) {
        //调用错误视图解析器的 resolveErrorView 解析到错误视图页面
        ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
        if (modelAndView != null) {
            return modelAndView;
        }
    }
    return null;
}

复制代码从上述源码可以看出，在响应页面的时候，会在父类的 resolveErrorView 方法中获取容器中所有的 ErrorViewResolver 对象（错误视图解析器，包括 DefaultErrorViewResolver 在内），一起来解析异常信息。

java复制代码ErrorMvcAutoConfiguration 还向容器中注入了一个默认的错误视图解析器组件 DefaultErrorViewResolver，代码如下。

java复制代码@Bean
@ConditionalOnBean(DispatcherServlet.class)
@ConditionalOnMissingBean(ErrorViewResolver.class)
DefaultErrorViewResolver conventionErrorViewResolver() {
    return new DefaultErrorViewResolver(this.applicationContext, this.resources);
}

java复制代码public class DefaultErrorViewResolver implements ErrorViewResolver, Ordered {

    private static final Map<HttpStatus.Series, String> SERIES_VIEWS;

    static {
        Map<HttpStatus.Series, String> views = new EnumMap<>(HttpStatus.Series.class);
        views.put(Series.CLIENT_ERROR, "4xx");
        views.put(Series.SERVER_ERROR, "5xx");
        SERIES_VIEWS = Collections.unmodifiableMap(views);
    }

    ......

    @Override
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
        //尝试以错误状态码作为错误页面名进行解析
        ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            //尝试以 4xx 或 5xx 作为错误页面页面进行解析
            modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
        }
        return modelAndView;
    }

    private ModelAndView resolve(String viewName, Map<String, Object> model) {
        //错误模板页面，例如 error/404、error/4xx、error/500、error/5xx
        String errorViewName = "error/" + viewName;
        //当模板引擎可以解析这些模板页面时，就用模板引擎解析
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
                this.applicationContext);
        if (provider != null) {
            //在模板能够解析到模板页面的情况下，返回 errorViewName 指定的视图
            return new ModelAndView(errorViewName, model);
        }
        //若模板引擎不能解析，则去静态资源文件夹下查找 errorViewName 对应的页面
        return resolveResource(errorViewName, model);
    }

    private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
        //遍历所有静态资源文件夹
        for (String location : this.resources.getStaticLocations()) {
            try {
                Resource resource = this.applicationContext.getResource(location);
                //静态资源文件夹下的错误页面，例如error/404.html、error/4xx.html、error/500.html、error/5xx.html
                resource = resource.createRelative(viewName + ".html");
                //若静态资源文件夹下存在以上错误页面，则直接返回
                if (resource.exists()) {
                    return new ModelAndView(new DefaultErrorViewResolver.HtmlResourceView(resource), model);
                }
            } catch (Exception ex) {
            }
        }
        return null;
    }
    ......
}

java复制代码
@Bean
@ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
public DefaultErrorAttributes errorAttributes() {
return new DefaultErrorAttributes();
}

java复制代码public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver, Ordered {
......
@Override
public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) {
Map<String, Object> errorAttributes = getErrorAttributes(webRequest, options.isIncluded(Include.STACK_TRACE));
if (!options.isIncluded(Include.EXCEPTION)) {
errorAttributes.remove("exception");
}
if (!options.isIncluded(Include.STACK_TRACE)) {
errorAttributes.remove("trace");
}
if (!options.isIncluded(Include.MESSAGE) && errorAttributes.get("message") != null) {
errorAttributes.remove("message");
}
if (!options.isIncluded(Include.BINDING_ERRORS)) {
errorAttributes.remove("errors");
}
return errorAttributes;
}

private Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
Map<String, Object> errorAttributes = new LinkedHashMap<>();
errorAttributes.put("timestamp", new Date());
addStatus(errorAttributes, webRequest);
addErrorDetails(errorAttributes, webRequest, includeStackTrace);
addPath(errorAttributes, webRequest);
return errorAttributes;
}
......
}

java复制代码在 Spring Boot 默认的 Error 控制器（BasicErrorController）处理错误时，会调用 DefaultErrorAttributes 的 getErrorAttributes() 方法获取错误或异常信息，并封装成 model 数据（Map 对象），返回到页面或 JSON 数据中。该 model 数据主要包含以下属性：

java复制代码public class ArrayStack {

    //实际存储数据的数组
    private int[] array;
    //stack的容量
    private int capacity;
    //stack头部指针的位置
    private int topIndex;

    public ArrayStack(int capacity){
        this.capacity= capacity;
        array = new int[capacity];
        //默认情况下topIndex是-1，表示stack是空
        topIndex=-1;
    }

    /**
     * stack 是否为空
     * @return
     */
    public boolean isEmpty(){
        return topIndex == -1;
    }

    /**
     * stack 是否满了
     * @return
     */
    public boolean isFull(){
        return topIndex == array.length -1 ;
    }

    public void push(int data){
        if(isFull()){
            System.out.println("Stack已经满了，禁止插入");
        }else{
            array[++topIndex]=data;
        }
    }

    public int pop(){
        if(isEmpty()){
            System.out.println("Stack是空的");
            return -1;
        }else{
            return array[topIndex--];
        }
    }
}

java复制代码public void push(int data){
        if(isFull()){
            System.out.println("Stack已经满了，stack扩容");
            expandStack();
        }
        array[++topIndex]=data;
    }

    //扩容stack，这里我们简单的使用倍增方式
    private void expandStack(){
        int[] expandedArray = new int[capacity* 2];
        System.arraycopy(array,0, expandedArray,0, capacity);
        capacity= capacity*2;
        array= expandedArray;
    }

java复制代码public class LinkedListStack {

    private Node headNode;

    class Node {
        int data;
        Node next;
        //Node的构造函数
        Node(int d) {
            data = d;
        }
    }

    public void push(int data){
        if(headNode == null){
            headNode= new Node(data);
        }else{
            Node newNode= new Node(data);
            newNode.next= headNode;
            headNode= newNode;
        }
    }

    public int top(){
        if(headNode ==null){
            return -1;
        }else{
            return headNode.data;
        }
    }

    public int pop(){
        if(headNode ==null){
            System.out.println("Stack是空的");
            return -1;
        }else{
            int data= headNode.data;
            headNode= headNode.next;
            return data;
        }
    }

    public boolean isEmpty(){
        return headNode==null;
    }
}

python复制代码#!/usr/bin/python2.6
# -*- coding: utf-8 -*-
import builtins
def test():
    print("dsada")
if __name__ == '__main__':
    #   增加内建函数
    builtins.__dict__["testFunc"] = test
    testFunc()
    pass

python复制代码    exec( "print('香菜')")

python复制代码x = 3
print(eval('3*x'))
​

python复制代码#!/usr/bin/env python
# encoding: utf-8
​
"""
#Author: 香菜
@time: 2021/10/10 0010 下午 10:22
"""
import builtins
def test():
    print("dsada")
if __name__ == '__main__':
    #   增加内建函数
    builtins.__dict__["testFunc"] = test
    testFunc()
    pass
​

java复制代码    /**
    * @Description: 将文件中的文字一行一行读取出来并存放在List中返回
    * @Param: [filename] 文件名
    * @return java.util.List<java.lang.String>
    */
public static List<String> readFileByLine(String filename) throws IOException, FileNotFoundException {
    List<String> stringList=new ArrayList<String>();
    File file=new File(filename);
    InputStreamReader isr=new InputStreamReader(new FileInputStream(file),"UTF-8");
    BufferedReader reader=new BufferedReader(isr);
    String tmp;
    while((tmp=reader.readLine())!=null){
        stringList.add(tmp);
    }
    reader.close();
    return stringList;
}

java复制代码
    /**
        * @Description: 生成图片的方法
        * @Param: [string] 生成图片的文字内容
        * @return void
        */
    public static void generateImg(String string) throws IOException{
        // 设置图片宽高
        int width=400;
        int height=400;
        // 设置图片的路径
        String filename="D:/"+string+".jpg";
        System.out.println(filename);
        File file=new File(filename);
        // 不需要引入外部字体
        Font font=new Font("黑体",Font.BOLD,60);
        // 引入外部字体
        //Font font =  getSelfDefinedFont("E:\PangMenZhengDaoBiaoTiTi\思源宋体.ttf");
        BufferedImage bi =new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2=(Graphics2D) bi.getGraphics();
        g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g2.setBackground(getRandomColor());
        g2.clearRect(0, 0, width, height);
        g2.setFont(font);
        FontMetrics fm = g2.getFontMetrics(font);
        int textWidth = fm.stringWidth(string);
        g2.setPaint(new Color(0,0,128));
        // 设置图片水平居中
        int widthX = (width - textWidth) / 2;
        // y设置高度，目前还没有研究出居中的方法
        g2.drawString(string, widthX , 220);
        ImageIO.write(bi,"jpg", file);
    }

java复制代码/**
    * @Description: 设置随机浅色颜色
    * @Param: []
    * @return java.awt.Color
    */
private static Color getRandomColor() {
    Random random=new Random();
    // 我这边设置了返回浅色的图片，排除了深色
    return new Color(random.nextInt(255)%(255-230+1) + 200,random.nextInt(255)%(255-230+1) + 200,random.nextInt(255)%(255-230+1) + 200);
}

java复制代码String fileName="D:/name.txt";
List<String> nameList = readFileByLine(fileName);
for (int i = 0; i < nameList.size(); i++) {
    generateImg(nameList.get(i));
}

java复制代码public class WindowDemo {

    public static void solution(int n){
        //这里模拟了一个滑动窗口数据模拟的过程，WindowData代表滑窗内维护的数据
        int WindowData = 0;
        if(n<=0)
            n=2;
        //在该数据上滑动
        int a[] = {-1,2,3,7,-10,6};

        //初始化，默认n为2
        for(int i = 0;i < n; i++)
            WindowData = WindowData+a[i];

        System.out.println("窗内数据为："+WindowData);

        int max = WindowData;

        //模拟滑动统计的过程
        for(int i = n ; i < a.length ; i++){
            //向前滑动一格
            WindowData = WindowData+a[i]-a[i-n];

            System.out.println("窗内数据为："+WindowData);

            //更新最大值
            if(max < WindowData)
                max = WindowData;

        }

        System.out.println("最大值为"+max);
    }

    public static void main(String[] args) {
        solution(2);

    }
}

java复制代码
public class WindowWrap<T> {

   
    //窗口分配到的时间段长度
    private final long windowLengthInMs;
    
    //窗口开始时间
    private long windowStart;

    //窗口数据
    private T value;

   //构造方法
    public WindowWrap(long windowLengthInMs, long windowStart, T value) {
        this.windowLengthInMs = windowLengthInMs;
        this.windowStart = windowStart;
        this.value = value;
    }
    
    
    public long windowLength() {
        return windowLengthInMs;
    }

    public long windowStart() {
        return windowStart;
    }

    public T value() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

   
    public WindowWrap<T> resetTo(long startTime) {
        this.windowStart = startTime;
        return this;
    }

    //判断是否为时间样本窗口，窗口开始时间+窗口时间长度小于当前时间
    public boolean isTimeInWindow(long timeMillis) {
        return windowStart <= timeMillis && timeMillis < windowStart + windowLengthInMs;
    }

    @Override
    public String toString() {
        return "WindowWrap{" +
            "windowLengthInMs=" + windowLengthInMs +
            ", windowStart=" + windowStart +
            ", value=" + value +
            '}';
    }
}

java复制代码
public abstract class LeapArray<T> {


    //每个样本窗口的长度
    protected int windowLengthInMs;
    //样本窗口数
    protected int sampleCount;
    //毫秒为单位一个滑动窗口跨越多少时间长度
    protected int intervalInMs;
    //秒为单位一个滑动窗口跨越多少时间长度
    private double intervalInSecond;
    
    //样本窗口的集合，用AtomicReferenceArray存储，长度为sampleCount（样本窗口的数目）
    protected final AtomicReferenceArray<WindowWrap<T>> array;

    private final ReentrantLock updateLock = new ReentrantLock();
    //进行参数的初始化
    public LeapArray(int sampleCount, int intervalInMs) {
        AssertUtil.isTrue(sampleCount > 0, "bucket count is invalid: " + sampleCount);
        AssertUtil.isTrue(intervalInMs > 0, "total time interval of the sliding window should be positive");
        AssertUtil.isTrue(intervalInMs % sampleCount == 0, "time span needs to be evenly divided");

        this.windowLengthInMs = intervalInMs / sampleCount;
        this.intervalInMs = intervalInMs;
        this.intervalInSecond = intervalInMs / 1000.0;
        this.sampleCount = sampleCount;

        this.array = new AtomicReferenceArray<>(sampleCount);
    }
    
    //...省略其他代码
   
}

kotlin复制代码private final LeapArray<MetricBucket> data;

java复制代码
public class MetricBucket {

    //计数器，统计各中events的数目
    private final LongAdder[] counters;

    private volatile long minRt;
    
    //构造方法
    public MetricBucket() {
        MetricEvent[] events = MetricEvent.values();
        this.counters = new LongAdder[events.length];
        for (MetricEvent event : events) {
            counters[event.ordinal()] = new LongAdder();
        }
        initMinRt();
    }

    //...省略部分代码

    public long get(MetricEvent event) {
        return counters[event.ordinal()].sum();
    }
    
    //往计数器里的增加PASS的数量
    public MetricBucket add(MetricEvent event, long n) {
        counters[event.ordinal()].add(n);
        return this;
    }
    //获得目前时间段通过的请求数目，用于跟规则比较，判断是否限流
    public long pass() {
        return get(MetricEvent.PASS);
    }
    //新的请求通过了，在此处添加统计
    public void addPass(int n) {
        add(MetricEvent.PASS, n);
    }
    
    //...省略部分代码
    
}

java复制代码//执行链路的下一个slot判断是否限流
fireEntry(context, resourceWrapper, node, count, prioritized, args);
//增加线程数
node.increaseThreadNum();
//没有报错，执行到这里了说明完全通过了，增加请求通过数，往滑动窗口里更新
node.addPassRequest(count);

java复制代码private transient volatile Metric rollingCounterInSecond = new ArrayMetric(SampleCountProperty.SAMPLE_COUNT,
    IntervalProperty.INTERVAL);
@Override
public void addPassRequest(int count) {
    rollingCounterInSecond.addPass(count);
    rollingCounterInMinute.addPass(count);
}

java复制代码private final LeapArray<MetricBucket> data;

@Override
public void addPass(int count) {
    //获取当前时间下的样本时间窗
    WindowWrap<MetricBucket> wrap = data.currentWindow();
    //增加请求通过数目
    wrap.value().addPass(count);
}

java复制代码public WindowWrap<T> currentWindow() {
    //获取当前时间点
    return currentWindow(TimeUtil.currentTimeMillis());
}

java复制代码public WindowWrap<T> currentWindow(long timeMillis) {
    if (timeMillis < 0) {
        return null;
    }
    //计算当前时间所在的样本窗口id，即在计算数据LeapArray中的索引
    int idx = calculateTimeIdx(timeMillis);
    
    //计算当前样本窗口的开始时间点
    long windowStart = calculateWindowStart(timeMillis);
    
    while (true) {
        // 获取到当前时间所在的样本窗口
        WindowWrap<T> old = array.get(idx);
        //若当前时间所在样本窗口为null，说明还不存在，创建一个
        if (old == null) {
            //创建一个时间窗
            WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
            if (array.compareAndSet(idx, null, window)) {
                // 创建成功返回窗口
                return window;
            } else {
                Thread.yield();
            }
            //若当前样本窗口的开始时间与计算出的样本窗口的开始时间相同
            //则说明这两个是同一个样本窗口
        } else if (windowStart == old.windowStart()) {
            return old;
            //若当前样本窗口的开始时间点大于计算出的样本窗口的开始时间
            //则说明计算出的样本窗口已经过时了，需要将原来的样本窗口替换
        } else if (windowStart > old.windowStart()) {
            
            if (updateLock.tryLock()) {
                try {
                    return resetWindowTo(old, windowStart);
                } finally {
                    updateLock.unlock();
                }
            } else {
                Thread.yield();
            }
        } else if (windowStart < old.windowStart()) {
            return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
        }
    }
}

java复制代码private int calculateTimeIdx(/*@Valid*/ long timeMillis) {
    //当前时间除以样本窗口的长度
    long timeId = timeMillis / windowLengthInMs;
    // Calculate current index so we can map the timestamp to the leap array.
    return (int)(timeId % array.length());
}

java复制代码protected long calculateWindowStart(/*@Valid*/ long timeMillis) {
    return timeMillis - timeMillis % windowLengthInMs;
}

java复制代码if (old == null) {
        //创建一个时间窗
        WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
        if (array.compareAndSet(idx, null, window)) {
            // 创建成功返回窗口
            return window;
        } else {
            Thread.yield();
        }
}

java复制代码        //若当前样本窗口的开始时间与计算出的样本窗口的开始时间相同
        //则说明这两个是同一个样本窗口
        else if (windowStart == old.windowStart()) {
            return old;
           
        }

java复制代码
        //若当前样本窗口的开始时间点大于计算出的样本窗口的开始时间
        //则说明计算出的样本窗口已经过时了，需要将原来的样本窗口替换
        else if (windowStart > old.windowStart()) {
            
            if (updateLock.tryLock()) {
                try {
                    return resetWindowTo(old, windowStart);
                } finally {
                    updateLock.unlock();
                }
            } else {
                Thread.yield();
            }
        }

java复制代码private final LeapArray<MetricBucket> data;

@Override
public void addPass(int count) {
    //获取当前时间下的样本时间窗
    WindowWrap<MetricBucket> wrap = data.currentWindow();
    //增加请求通过数目
    wrap.value().addPass(count);
}

java复制代码public MetricBucket add(MetricEvent event, long n) {
    counters[event.ordinal()].add(n);
    return this;
}

ini复制代码public int lengthOfLongestSubstring2(String s) {
    int n = s.length();
    if (n <= 1) return n;
    int maxLen = 1;

    //左、右指针
    int left = 0, right = 0;
  
    Set<Character> window = new HashSet<>();
    while (right < n) {
        char rightChar = s.charAt(right);
        while (window.contains(rightChar)) {
            window.remove(s.charAt(left));
            left++;
        }
        //最大长度对比
        maxLen = Math.max(maxLen, right - left + 1);
        window.add(rightChar);
        right++;
    }

    return maxLen;
}

java复制代码public class DeadLockTest {
    public static void main(String[] args) {
        Object lock1 = new Object(); // 锁1
        Object lock2 = new Object(); // 锁2

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 先获取锁1
                synchronized (lock1) {
                    System.out.println("Thread 1:获取到锁1!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //获取锁2
                    System.out.println("Thread 1:等待获取2...");
                    synchronized (lock2) {
                        System.out.println("Thread 1:获取到锁2!");
                    }
                }
            }
        });
        t1.start(); 

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 先获取锁2
                synchronized (lock2) {
                    System.out.println("Thread 2:获取到锁2!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 获取锁1
                    System.out.println("Thread 2:等待获取1...");
                    synchronized (lock1) {
                        System.out.println("Thread 2:获取到锁1!");
                    }
                }
            }
        });
        t2.start(); 
    }
}

arduino复制代码/opt/java8/bin/jstack

Usage:
    jstack [-l] <pid>
        (to connect to running process) 连接活动线程
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process) 连接阻塞线程
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file) 连接dump的文件
    jstack [-m] [-l] [server_id@]<remote server IP or hostname>
        (to connect to a remote debug server) 连接远程服务器

Options:
    -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
    -m  to print both java and native frames (mixed mode)
    -l  long listing. Prints additional information about locks
    -h or -help to print this help message

php复制代码"mythread2" #12 prio=5 os_prio=0 tid=0x0000000058ef7800 nid=0x1ab4 waiting on condition [0x0000000059f8f000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$2.run(DeathLock.java:34)

   Locked ownable synchronizers:
        - <0x00000000d602d640> (a java.util.concurrent.locks.ReentrantLock$Nonfa
irSync)

"mythread1" #11 prio=5 os_prio=0 tid=0x0000000058ef7000 nid=0x3e68 waiting on condition [0x000000005947f000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$1.run(DeathLock.java:22)

   Locked ownable synchronizers:
        - <0x00000000d602d610> (a java.util.concurrent.locks.ReentrantLock$Nonfa
irSync)


Found one Java-level deadlock:
=============================
"mythread2":
  waiting for ownable synchronizer 0x00000000d602d610, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
  which is held by "mythread1"
"mythread1":
  waiting for ownable synchronizer 0x00000000d602d640, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
  which is held by "mythread2"

Java stack information for the threads listed above:
===================================================
"mythread2":
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d610> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$2.run(DeathLock.java:34)
"mythread1":
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d602d640> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)

        at DeathLock$1.run(DeathLock.java:22)

Found 1 deadlock.