Quelle AcrossThreads.java Sprache: JAVA

/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

/*
* @test
* @bug 8143214
* @summary Verify that StackWalker works well when one instance of StackWalker
*          is used by several threads sequentially or concurrently.
* @run testng AcrossThreads
*/

import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import java.lang.StackWalker.StackFrame;
import static java.lang.StackWalker.Option.*;

import org.testng.annotations.*;
import static org.testng.Assert.*;

public class AcrossThreads {
    static final StackWalker WALKERS[] = new StackWalker[] {
            StackWalker.getInstance(RETAIN_CLASS_REFERENCE),
            StackWalker.getInstance(EnumSet.of(SHOW_REFLECT_FRAMES, RETAIN_CLASS_REFERENCE)),
            StackWalker.getInstance(EnumSet.of(SHOW_HIDDEN_FRAMES, RETAIN_CLASS_REFERENCE))
    };

    @DataProvider
    public StackWalker[][] walkerProvider() {
        return new StackWalker[][] {
                new StackWalker[] { WALKERS[0] },
                new StackWalker[] { WALKERS[1] },
                new StackWalker[] { WALKERS[2] }
        };
    }

    @Test(dataProvider = "walkerProvider")
    public void test(StackWalker walker) {
        Thread t1 = new T1(walker);
        // call methods of one instance of StackWalker sequentially in T1, T2, T3.
        t1.start();
        try {
            t1.join();
        } catch (InterruptedException e) { }

        List<Thread> threads = new ArrayList<Thread>();
        for (int i = 0; i < 100; i++) {
            threads.add(new T1(walker));
            threads.add(new T2(walker));
            threads.add(new T3(walker));
        }
        // call methods of one instance of StackWalker concurrently in several threads.
        threads.parallelStream().forEach(t -> {
            t.setDaemon(true);
            t.start();
        });
        threads.parallelStream().forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) { }
        });
    }

    interface Consumer {
        final int LOOPS = 5;

        public void consume();

        default public void assertWalker(StackWalker walker, int n) {
            if (--n == 0) {
                Map<String, Integer> methods = new HashMap<String, Integer>();
                walker.forEach(f -> {
                    Integer i = methods.putIfAbsent(f.getMethodName(), 1);
                    if (i != null) {
                        methods.put(f.getMethodName(), i + 1);
                    }
                });

                // verify that walker.forEach(...) reaches the specified methods.
                assertTrue(methods.get("consume") == 1);
                assertTrue(methods.get("run") == 1);
                assertTrue(methods.get("assertWalker") == LOOPS);

                // verify that walker.walk(...) reaches the specified methods.
                assertTrue(walker.walk(s -> s.map(StackFrame::getMethodName)
                                             .filter(mn -> mn.equals("consume"))
                                             .count()) == 1);
                assertTrue(walker.walk(s -> s.map(StackFrame::getMethodName)
                                             .filter(mn -> mn.equals("run"))
                                             .count()) == 1);
                assertTrue(walker.walk(s -> s.map(StackFrame::getMethodName)
                                             .filter(mn -> mn.equals("assertWalker"))
                                             .count()) == LOOPS);
            } else {
                assertWalker(walker, n);
            }
        }
    }

    class T1 extends Thread implements Consumer {
        final StackWalker walker;

        public T1(StackWalker walker) {
            this.walker = walker;
        }

        public void run() {
            consume();

            Thread t2 = new T2(walker);
            t2.start();
            try {
                t2.join();
            } catch (InterruptedException e) { }

            consume();
        }

        public void consume() {
            assertWalker(walker, LOOPS);

            // verify walker.walk() reaches T1 class through methods run() and consume().
            assertTrue(walker.walk(s -> s.filter(f -> T1.class == f.getDeclaringClass())
                                         .count()) == 2);

            assertCallerClass(walker);
            assertEquals(T1.class, walker.getCallerClass());
        }
    }

    class T2 extends Thread implements Consumer {
        final StackWalker walker;

        public T2(StackWalker walker) {
            this.walker = walker;
        }

        public void run() {
            consume();

            Thread t3 = new T3(walker);
            t3.start();
            try {
                t3.join();
            } catch (InterruptedException e) { }

            consume();
        }

        public void consume() {
            assertWalker(walker, LOOPS);

            // verify walker.walk() reaches T2 class through methods run() and consume().
            assertTrue(walker.walk(s -> s.filter(f -> T2.class == f.getDeclaringClass())
                                         .count()) == 2);
            // verify T1 is not reached, even if call is invoked
            // from test()->T1.start()->T1.run()->T2
            assertTrue(walker.walk(s -> s.filter(f -> T1.class == f.getDeclaringClass())
                                         .count()) == 0);

            assertCallerClass(walker);
            assertEquals(T2.class, walker.getCallerClass());
        }
    }

    class T3 extends Thread implements Consumer {
        final StackWalker walker;

        public T3(StackWalker walker) {
            this.walker = walker;
        }

        public void run() {
            consume();
        }

        public void consume() {
            assertWalker(walker, LOOPS);

            // verify walker.walk() reaches T1 class through methods run() and consume().
            assertTrue(walker.walk(s -> s.filter(f -> T3.class == f.getDeclaringClass())
                                         .count()) == 2);
            // verify T1, T2 is not reached, even if call is invoked
            // from test() -> T1.start() -> T1.run() -> T2.start() -> T2.run() -> T3
            assertTrue(walker.walk(s -> s.filter(f -> T2.class == f.getDeclaringClass())
                                         .count()) == 0);
            assertTrue(walker.walk(s -> s.filter(f -> T1.class == f.getDeclaringClass())
                                         .count()) == 0);

            assertCallerClass(walker);
            assertEquals(T3.class, walker.getCallerClass());
        }
    }

    static void assertCallerClass(StackWalker walker) {
        // verify walker.getCallerClass() get the expected class.
        call(walker);
    }

    static void call(StackWalker walker) {
        Class<?> c = walker.getCallerClass();
        assertEquals(c, AcrossThreads.class);
    }
}

quality84%

¤ Dauer der Verarbeitung: 0.13 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.