How to get last few stack frames instead of a complete stack trace in Java 8?

There is the Stack Walking API in Java 9 which allows us to get only the last couple of stack frames. But I am stuck with Java 8. In Java 8 we can get the Stack trace with either Thread.currentThread().getStackTrace() or new Throwable().getStackTrace() but both of these methods are slow because they construct the whole stack trace. Is there any way to limit the number of frames in the stack trace (to construct only the last 3 frames for example)?

Update:
I tested Stephen's code and it works really well. It really reduces execution time by a constant factor depending on the the depth chosen. What I found interesting is that it does not reduce the time to create a new Exception even though the stack trace is constructed during exception creation and stored in an internal format. Most of the time is spent converting this internal format to a StackTraceElement when getStackTrace() is called. So if the stack trace is shallower, than of course it takes less time to convert it. But why doesn't it take less time to create the internal representation of the stack trace when the exception is created(new Throwable())?

    public static void main(String[] args) throws IOException {
        f1();
    }

    private static void f1() {
       f2();
    }

    private static void f2() {
       f3();
    }

    private static void f3() {
       f4();
    }

    private static void f4() {
        f5();
    }

    private static void f5() {
        int sum = 0;
        long l = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            Throwable throwable = new Throwable();
            //comment out to test the internal representation -> StackTraceElement conversion
            //StackTraceElement[] trace = throwable.getStackTrace();
            //sum += trace.length;
        }
        long l2 = System.currentTimeMillis();
        System.out.println(l2-l);
        System.out.println(sum);
    }

Update 2: Trying to eliminate benchamrk issues, I stored all my Throwable instances in an array then at the end of execution I retrieved one of them by random and printed the stack trace. I think this would prevent any optimizations done to eliminate the new Throwable() calls.

        int sizez = 2000000;
        Throwable[] th = new Throwable[sizez];
        for (int i = 0; i < sizez; i++) {
            th[i] = new Throwable();
            //StackTraceElement[] trace = throwable.getStackTrace();
            //sum += trace.length;
        }
        long l2 = System.currentTimeMillis();
        System.out.println(l2-l);
        System.out.println(sum);

        Random rand = new Random();
        StackTraceElement[] trace = th[rand.nextInt(sizez)].getStackTrace();
        System.out.println(trace[0]);

You can use the JVM option -XX:MaxJavaStackTraceDepth=depth to limit the size of stacktraces.

However, this applies to all stacktraces, and it doesn't sound like it is what you need. I don't think there is a way to limit the size on a case by case basis.