多线程与高并发（四）

最新推荐文章于 2024-06-03 15:27:09 发布
最新推荐文章于 2024-06-03 15:27:09 发布
阅读量708 收藏
点赞数
分类专栏： Java多线程 文章标签： java 面试 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuanduan/article/details/128480334
版权

【Exchanger】：

package Ten_Class.t04.no139;

import java.util.concurrent.Exchanger;

public class T12_TestExchanger {

    static Exchanger<String> exchanger = new Exchanger<>();

    public static void main(String[] args) {
        new Thread(() -> {
            String s = "T1";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);

        }, "t1").start();


        new Thread(() -> {
            String s = "T2";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);

        }, "t2").start();


    }
}

在这里插入图片描述
在这里插入图片描述
//交换后两个线程继续往前跑。（ 先执行exchange()方法的线程会进入阻塞状态 ）

【Exchanger注意】：

只能是两个线程之间，三个以及以上不清楚如何交换。
两个线程一个执行了exchange()方法 ， 另一个不执行，那么执行的那个线程会进入阻塞状态。

【 复习总结 】：

  • synchronized
  • volatile
  • AtomicXXX
  • 各种JUC同步锁
    ReentrantLock
    CountDownLatch
    CyclicBarrier
    Phaser
    ReadWriteLock - StampedLock
    Semaphore
    Exchanger
    LockSupport
    //JUC的锁中除了最后的LockSupport之外，其它的都是利用AQS来实现的。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

【synchronized 和 ReentrantLock的不同之处 】：

sync系统自动加锁，自动解锁，RL需要我们手动加锁，手动解锁，RL可以出现各种各样的Condition , Condition代表的是不同的等待队列，RL底层是CAS实现，sync是四种状态的升级。

【淘宝面试题】：

实现一个容器，提供两个方法，add , size ;写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。
【面试题】：
写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

【 LockSupport 】：

package Ten_Class.t04.no141;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T13_TestLockSupport00 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park();  //park是停车的意思；————当前线程停止。
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        try {
            TimeUnit.SECONDS.sleep(8);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after 8 senconds!");

        LockSupport.unpark(t);    //叫醒线程。
    }
}

在这里插入图片描述

【实验】：

package Ten_Class.t04.no141;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T13_TestLockSupport01 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park();  //park是停车的意思；————当前线程停止。
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();
        LockSupport.unpark(t);
    }
}

在这里插入图片描述
LockSupport.unpark(t); //这一句话是同时和t线程启动的。
//但是一上来t线程没有进行park , 这说明unpark可以先于park进行调用。先调用的话之后就没办法停车了，之后就没办法再调park()方法了。
先调用unpark()方法的话，之后的park()方法就相当于失效了。这种方法比wait、notify要更加灵活。

【 Volatile 】：

在这里插入图片描述

package Ten_Class.t04.no142;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T01_WithoutVolatile {

    List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T01_WithoutVolatile c = new T01_WithoutVolatile();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c.size() == 5) {
                    break;
                }
            }
            System.out.println(" t2  结束 ");
        }, "t2").start();
    }
}

在这里插入图片描述
//发现不行。
【错误点】：
1）没有加同步。
2）停止不了是因为永远没有检测到——线程之间不可见的问题。第一个线程变化了之后，第二个线程不会马上就能看到。

【 改 正 之 后 】：

package Ten_Class.t04.no142;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class T02_WithVolatile {
    //添加volatile ， 使t2能够得到通知֪ͨ
    volatile List lists = Collections.synchronizedList(new LinkedList<>());

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {

        T02_WithVolatile c = new T02_WithVolatile();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c.size() == 5) {
                    break;
                }
            }
            System.out.println("t2  结束");
        }, "t2").start();
    }
}

在这里插入图片描述

【注意】：

volatile List lists = Collections.synchronizedList(new LinkedList<>()); 
		//同步容器。

【 wait、notify 】：

【错误示例】：

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 * <p>
 * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
 * <p>
 * 阅读下面的程序，并分析输出结果
 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
 * 想想这是为什么？
 */
package Ten_Class.t04.no143;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T03_NotifyHoldingLock { //wait notify

    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T03_NotifyHoldingLock c = new T03_NotifyHoldingLock();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 start");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 end");
            }

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1 start");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();     //不释放锁————虽然叫醒了，但是没有拿到锁。
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

在这里插入图片描述

【修改】：

package Ten_Class.t04.no143;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T04_NotifyFreeLock {

    //添加volatile ，使t2能够得到通知。
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T04_NotifyFreeLock c = new T04_NotifyFreeLock();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 启动");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                //ͨ通知֪t继续执行1
                lock.notify();
            }

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1～～～启动");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();
                        // 释放锁，让t2得以执行。
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

在这里插入图片描述

【最核心的点】：

notify不会释放锁 ， 而wait是会释放锁的。wait要回来继续执行的时候还需要拿到锁才能继续执行。

【 CountDownLatch 、Semaphore 】：

package Ten_Class.t04.no145;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.LockSupport;

public class T08_Semaphore {
    //添加volatile ， 使t2能够得到通知。
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        T08_Semaphore c = new T08_Semaphore();
        Semaphore s = new Semaphore(1);

        t1 = new Thread(() -> {
            try {
                s.acquire();
                for (int i = 0; i < 5; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);


                }
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                t2.start();
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                s.acquire();
                for (int i = 5; i < 10; i++) {
                    System.out.println(i);
                }
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "t1");

        t2 = new Thread(() -> {
            try {
                s.acquire();
                System.out.println("t2  结束");
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2");

        //t2.start();
        t1.start();
    }
}

【 最终输出 】：
在这里插入图片描述

【 交叉打印案例 】：

在这里插入图片描述

【 synchronized 】：

【面试题】：

  • 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
  • 能够支持2个生产者线程以及10个消费者线程的阻塞调用。
    【解释】：
    生产者线程生产的东西装不下了，生产线程就会进入阻塞状态 ， 同样拿的线程拿不到东西了也会进入阻塞状态。
/**
 * 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
 * 能够支持2个生产者线程以及10个消费者线程的阻塞调用
 * <p>
 * 使用wait和notify/notifyAll来实现
 * <p>
 * 使用Lock和Condition来实现
 * 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
 */
package Ten_Class.t04.no146;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;

public class MyContainer1<T> {
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10; //最多10个元素
    private int count = 0;


    public synchronized void put(T t) {
        while (lists.size() == MAX) { //想想为什么用while而不是用if？
            try {
                //this.notifyAll()
                this.wait(); //effective java
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        lists.add(t);
        ++count;
        this.notifyAll(); //通知消费者线程进行消费
    }

    public synchronized T get() {
        T t = null;
        while (lists.size() == 0) {
            try {
                //this.notifyAll()
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = lists.removeFirst();
        count--;
        this.notifyAll(); //通知生产者进行生产
        return t;
    }

    public static void main(String[] args) {
        MyContainer1<String> c = new MyContainer1<>();
        //启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) System.out.println(c.get());
            }, "c" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "p" + i).start();
        }
    }
}

【 背过这种写法 】：

    public synchronized void put(T t) {
        while (lists.size() == MAX) { //想想为什么用while而不是用if？
            //while后面的判断说明已经扔满了。

            try {
                //this.notifyAll()
                this.wait(); //effective java      //当前线程停住。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        lists.add(t);
        ++count;
        this.notifyAll(); //通知消费者线程进行消费
    }

在这里插入图片描述
//加synchronized是因为有 ++count 这一句。

【 CAS 】：

【能否？】：
生产者线程只负责叫醒消费者；
消费者线程只负责叫醒生产者。

//下面的写法可以满足这个要求。

【 满足要求的写法 】：

/**
 * 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
 * 能够支持2个生产者线程以及10个消费者线程的阻塞调用
 * <p>
 * 使用wait和notify/notifyAll来实现
 * <p>
 * 使用Lock和Condition来实现
 * 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
 *
 * @author mashibing
 */
package Ten_Class.t04.no146;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyContainer2<T> {
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10; //最多10个元素
    private int count = 0;

    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public void put(T t) {
        lock.lock();
        try {
            while (lists.size() == MAX) { //想想为什么用while而不是用if？
                producer.await();
            }

            lists.add(t);
            ++count;
            consumer.signalAll(); //通知消费者线程进行消费
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public T get() {
        T t = null;
        lock.lock();
        try {
            while (lists.size() == 0) {
                consumer.await();
            }
            t = lists.removeFirst();
            count--;
            producer.signalAll(); //通知生产者进行生产
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return t;
    }

    public static void main(String[] args) {
        MyContainer2<String> c = new MyContainer2<>();
        //启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) System.out.println(c.get());
            }, "c" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "p" + i).start();
        }
    }
}

【本质】：

    private Condition producer = lock.newCondition();       //第一个条件；
    private Condition consumer = lock.newCondition();       //第二个条件；

Condition的本质就是等待队列 ；
在这里插入图片描述
当producer.awit( )的时候 ， 指的是这个线程进入P队列等待 ， 当consumer.awit（ ）的时候 ， 指的是这个线程进入C队列等待。
这样叫醒的时候，可以当读叫醒某个队列里的全部线程。
所以Condition的本质就是不同的等待队列。

【 探索源码 】：

【读源码的基础】：
1）数据结构基础
2）设计模式

【读源码的思路】：

更重要的是借鉴别人的思路 ， 具体的边界判定条件其实可以忽略。

【 AQS核心 】：

Template Method
Callback Function
父类默认实现
子类具体实现

【 源码阅读原则 】：

在这里插入图片描述
//有时候静态读会读不下去 ， 但是动态DEBUG就会发现问题所在。（有时会因为多态机制）
第一遍读的时候一些边界条件判断可以略过。

【 ReentrantLock 】：

    public void lock() {
        sync.lock();
    }
-->
private final Sync sync;    //sync原来是一个内部类；
-->
abstract static class Sync extends AbstractQueuedSynchronizer { ... }
Android 性能优化（三）认识错误Error和异常Exception及栈轨迹StackTrace
csdn_aiyang的博客
03-19 5172
前言 Android 性能优化之内存检测、卡顿优化、耗电优化、APK瘦身，这篇中我强调“运行稳定大于一切”，保证程序运行中不出现Crash，要比卡顿、耗电、安装包大小等方面更为重要。 造成Crash的原因有很多，而在程序运行过程中抛出了异常或错误就是其中最普遍的成因。本篇将对Exception和error有一个比较全面的认识。（当然，有不足之处，请多多包涵） 一、定义 th...
多线程使用不当导致的 OOM
java_beautiful的博客
07-04 230
从 6 点 32 分开始少量用户访问 App 时会出现首页访问异常，到 7 点 20 分首页服务大规模不可用，7 点 36 分问题解决。
Thread.currentThread().getStackTrace()[?]
qq_37361360的博客
10-26 1900
原文地址：点击跳转 测试代码： public static void main(String[] args) { getName4(); } public static void getName1() { String methodName0 = Thread.currentThread().getStackTrace()[0].getMethodName(); String methodName1 = Thread.curren.
浅谈getStackTrace()方法
qq_43842093的博客
06-23 784
可以看到加了一个私有方法之后，返回的堆栈元素就多了一个，并且它的。返回一个堆栈轨迹元素的数组，代表了这个线程的堆栈情况。第二个方法：（阅读Java SE的文档：），即是这个调用序列中最recent的方法。如果再用一个私有方法，输出调用堆栈的信息。输出的结果很简单，就是调用类的方法名。数组，每个数组代表一个堆栈帧。如果返回的数组长度不为0，那么。，即调用序列中最远的一个元素。程序实测——Java程序。
关于Thread.getStrackTrace
qq_42133677的博客
04-27 448
关于Thread.getStrackTrace 说明文档： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P1hsEKC4-1587998893106)(C:%5CUsers%5CAdministrator%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20200418104635344.png)...
得到当前方法的名字Thread.currentThread().getStackTrace()[1].getMethodName();
u011159607的博客
10-23 5536
一个thread就是一个线程，当你编程使用多线程的时候，用currentthread（）这个method来获取当前运行线程，以便对其进行操作。 简单来说就是 Tthread类(线程类) 中的一个方法 Thread.currentThread() 是指获取当前运行的线程对象 例如: Thread.currentThread().getName() 就是获取当前运行的线程的名称
多线程与高并发-电子.pdf
05-03
多线程与高并发是计算机科学中非常重要的两个概念，它们在提高软件程序的性能、响应速度和资源利用率方面起着至关重要的作用。在当今的互联网时代，特别是在产业互联网和5G技术的推动下，多线程和高并发的应用变得...
多线程，高并发.pdf
08-15
4. 当一个线程进入一个对象的一个 synchronized 方法后，其它线程是否可进入此对象的其它方法? 5. 简述 synchronized 和 java.util.concurrent.locks.Lock 的异同？ 6. 概括的解释下线程的几种可用状态。
多线程与高并发实战手册.rar
03-20
本文将基于《多线程与高并发实战手册》中的知识点，深入探讨这两个主题。 首先，多线程是指在一个程序中同时运行多个线程，这使得程序能够并行处理任务，提高系统的效率和响应速度。Java、Python、C++等编程语言都...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，我们可以推测它可能包含了关于如何在AI项目中应用多线程技术以实现高效并发处理的资源，比如代码示例、教程或者研究报告。 多线程是指在一个...
【多线程与高并发编程】深入解析Java多线程机制：线程状态、同步方法及优化策略
最新发布
05-23
内容概要：本文详细介绍了多线程与高并发编程中的核心概念和技术细节，包括线程控制方法（如stop()、suspend()、sleep()、wait()）、同步与异步的区别及其应用场景、synchronized与Lock接口的比较、线程状态、...
Java 进阶：异常影响性能吗？
albon arith
09-24 1万+
Java 进阶：异常影响性能吗？曾经在给一个业务系统增加限流功能，使用的限流组件在流量超过阈值时，会直接抛异常，异常导致 CPU 占用率飙升。第一次遇到这样的情况，让我们不得不思考，异常怎么会对性能造成这么大的影响？下面我们写几个测试程序观察一下。
Java获取堆栈信息的3种方法
华为云官方博客
03-13 2584
Java提供了多种方式来获取当前线程的堆栈信息，以便了解线程执行的情况。
Java 面试题之 Logback 打印日志是如何获取当前方法名称的？
Wayn111的博客
11-12 443
本文有介绍四种方法获取当前执行方法名称，一般情况下大家使用异常对象的方法以及匿名内部类的方法都是可以的，它们的性能都 OK，代码书写复杂程度都大差不差。在 Java 9 以后推荐使用 Stack-Walking API，它的功能更为强大，与程序里的堆栈语意也跟为契合，性能 OK，并且还是线程安全的。关注公众号【waynblog】每周分享技术干货、开源项目、实战经验、国外优质文章翻译等，您的关注将是我的更新动力！
Thread.currentThread().getStackTrace()[1].getMethodName()获取方法名称
weixin_50443850的博客
06-03 232
【代码】Thread.currentThread().getStackTrace()[1].getMethodName()获取方法名称。
java 多线程&getStackTrace()方法——15
爱的叹息的专栏
06-06 700
getStackTrace()方法的作用是返回一个表示该线程 堆栈跟踪元素数组。如果该线程尚未启动或已经终止，则该方法将返回一 个零长度数组。如果返回的数组不是零长度的，则其第一个元素代表堆栈 顶，它是该数组中最新的方法调用。最后一个元素代表堆栈底，是该数组 中最旧的方法调用。...
Java异常的栈轨迹(Stack Trace)
HuiGui6的专栏
10-17 976
捕获到异常时，往往需要进行一些处理。比较简单直接的方式就是打印异常栈轨迹Stack Trace。说起栈轨迹，可能很多人和我一样，第一反应就是 printStackTrace()方法。其实除了这个方法，还有一些别的内容也是和栈轨迹有关的。      1.printStackTrace()     首先需要明确，这个方法并不是来自于Exception类。Exception类本身除了定义了几个构造
Java 获取当前或调用者类名和方法名（Thread.currentThread().getStackTrace()、new Throwable().getStackTrace()）
热门推荐
西京刀客
12-29 1万+
文章目录一、Java获取当前类名和方法名Thread.currentThread().getStackTrace()1. 关于Thread.currentThread().getStackTrace()2. Thread.currentThread().getStackTrace()这种直接获取堆栈的方法在中有何隐患吗?二、【推荐】Java获取当前类名和方法名new Throwable().getStackTrace()1. 关于Java Throwable getStackTrace()方法 一、Java
得到当前堆栈信息的两种方式（Thread和Throwable）的方法
疯狂的小马
11-19 5899
Thread.currentThread().getStackTrace()[2].getClassName(); 为什么是2 不是1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值