geode-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (GEODE-3936) Cleanup ThreadUtil
Date Thu, 02 Nov 2017 17:15:01 GMT

    [ https://issues.apache.org/jira/browse/GEODE-3936?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16236143#comment-16236143
] 

ASF GitHub Bot commented on GEODE-3936:
---------------------------------------

jinmeiliao closed pull request #998: GEODE-3936: remove ThreadUtils
URL: https://github.com/apache/geode/pull/998
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/geode-core/src/main/java/org/apache/geode/internal/lang/ThreadUtils.java b/geode-core/src/main/java/org/apache/geode/internal/lang/ThreadUtils.java
deleted file mode 100644
index 9797a183bf..0000000000
--- a/geode-core/src/main/java/org/apache/geode/internal/lang/ThreadUtils.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information
regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version
2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain
a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
express
- * or implied. See the License for the specific language governing permissions and limitations
under
- * the License.
- */
-
-package org.apache.geode.internal.lang;
-
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.lang.Thread.State;
-
-/**
- * The ThreadUtils class is an abstract utility class for working with and invoking methods
on
- * Threads.
- * <p/>
- * 
- * @see java.lang.Thread
- * @since GemFire 7.0
- */
-public abstract class ThreadUtils {
-
-  /**
-   * Gets the name of the particular Thread or null if the Thread object reference is null.
-   * <p/>
-   * 
-   * @param thread the Thread object whose name is returned.
-   * @return a String value indicating the name of the Thread or null if the Thread object
reference
-   *         is null.
-   * @see java.lang.Thread#getName()
-   */
-  public static String getThreadName(final Thread thread) {
-    return (thread == null ? null : thread.getName());
-  }
-
-  /**
-   * Interrupts the specified Thread, guarding against null.
-   * <p/>
-   * 
-   * @param thread the Thread to interrupt.
-   * @see java.lang.Thread#interrupt()
-   */
-  public static void interrupt(final Thread thread) {
-    if (thread != null) {
-      thread.interrupt();
-    }
-  }
-
-  /**
-   * Determines whether the specified Thread is alive, guarding against null Object references.
-   * <p/>
-   * 
-   * @param thread the Thread to determine for aliveness.
-   * @return a boolean value indicating whether the specified Thread is alive. Will return
false if
-   *         the Thread Object references is null.
-   * @see java.lang.Thread#isAlive()
-   */
-  public static boolean isAlive(final Thread thread) {
-    return (thread != null && thread.isAlive());
-  }
-
-  /**
-   * Determines whether the specified Thread is in a waiting state, guarding against null
Object
-   * references
-   * <p/>
-   * 
-   * @param thread the Thread to access it's state.
-   * @return a boolean value indicating whether the Thread is in a waiting state. If the
Thread
-   *         Object reference is null, then this method return false, as no Thread is clearly
not
-   *         waiting for anything.
-   * @see java.lang.Thread#getState()
-   * @see java.lang.Thread.State#WAITING
-   */
-  public static boolean isWaiting(final Thread thread) {
-    return (thread != null && thread.getState().equals(State.WAITING));
-  }
-
-  /**
-   * Causes the current Thread to sleep for the specified number of milliseconds. If the
current
-   * Thread is interrupted during sleep, the interrupt flag on the current Thread will remain
set
-   * and the duration, in milliseconds, of completed sleep is returned.
-   * <p/>
-   * 
-   * @param milliseconds an integer value specifying the number of milliseconds the current
Thread
-   *        should sleep.
-   * @return a long value indicating duration in milliseconds of completed sleep by the current
-   *         Thread.
-   * @see java.lang.System#nanoTime()
-   * @see java.lang.Thread#sleep(long)
-   */
-  public static long sleep(final long milliseconds) {
-    final long t0 = System.nanoTime();
-
-    try {
-      Thread.sleep(milliseconds);
-    } catch (InterruptedException ignore) {
-      Thread.currentThread().interrupt();
-    }
-
-    return (System.nanoTime() - t0) / 1000;
-  }
-
-  /**
-   * Returns a stack trace of the {@code Throwable} as a {@code String}.
-   * 
-   * @param throwable The throwable for which to create the stack trace.
-   * @param expectNull True if null should be returned when {@code throwable} is null or
false to
-   *        return "" when {@code throwable} is null
-   * @return null if {@code throwable} is null and {@code expectNull} is true, "" if
-   *         {@code throwable} is null and {@code expectNull} is false, otherwise the stack
trace
-   *         for {@code throwable}
-   */
-  public static String stackTraceToString(final Throwable throwable, final boolean expectNull)
{
-    if (throwable == null) {
-      if (expectNull == true) {
-        return null;
-      }
-
-      return "";
-    }
-
-    StringWriter stringWriter = new StringWriter();
-    PrintWriter printWriter = new PrintWriter(stringWriter);
-    throwable.printStackTrace(printWriter);
-    printWriter.close();
-    return stringWriter.toString();
-  }
-}
diff --git a/geode-core/src/main/java/org/apache/geode/internal/logging/log4j/AlertAppender.java
b/geode-core/src/main/java/org/apache/geode/internal/logging/log4j/AlertAppender.java
index a7151cc4c4..5f392575c6 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/logging/log4j/AlertAppender.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/logging/log4j/AlertAppender.java
@@ -20,6 +20,7 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.apache.commons.lang.exception.ExceptionUtils;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.core.LogEvent;
@@ -33,7 +34,6 @@
 import org.apache.geode.distributed.internal.InternalDistributedSystem;
 import org.apache.geode.internal.admin.Alert;
 import org.apache.geode.internal.admin.remote.AlertListenerMessage;
-import org.apache.geode.internal.lang.ThreadUtils;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.internal.tcp.ReenteredConnectException;
 
@@ -138,7 +138,8 @@ public void append(final LogEvent event) {
       final Date date = new Date(event.getTimeMillis());
       final String threadName = event.getThreadName();
       final String logMessage = event.getMessage().getFormattedMessage();
-      final String stackTrace = ThreadUtils.stackTraceToString(event.getThrown(), true);
+      final String stackTrace =
+          (event.getThrown() == null) ? null : ExceptionUtils.getStackTrace(event.getThrown());
       final String connectionName = ds.getConfig().getName();
 
       for (Listener listener : this.listeners) {
diff --git a/geode-core/src/test/java/org/apache/geode/internal/lang/ThreadUtilsJUnitTest.java
b/geode-core/src/test/java/org/apache/geode/internal/lang/ThreadUtilsJUnitTest.java
deleted file mode 100644
index 30af492369..0000000000
--- a/geode-core/src/test/java/org/apache/geode/internal/lang/ThreadUtilsJUnitTest.java
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information
regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version
2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain
a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
express
- * or implied. See the License for the specific language governing permissions and limitations
under
- * the License.
- */
-package org.apache.geode.internal.lang;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.*;
-
-import java.lang.Thread.State;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import edu.umd.cs.mtc.MultithreadedTestCase;
-import edu.umd.cs.mtc.TestFramework;
-import org.jmock.Expectations;
-import org.jmock.Mockery;
-import org.jmock.lib.concurrent.Synchroniser;
-import org.jmock.lib.legacy.ClassImposteriser;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-import org.apache.geode.test.junit.categories.UnitTest;
-
-/**
- * The ThreadUtilsJUnitTest class is a test suite of test cases for testing the contract
and
- * functionality of the ThreadUtils class.
- * <p/>
- * 
- * @see org.apache.geode.internal.lang.ThreadUtils
- * @see org.jmock.Expectations
- * @see org.jmock.Mockery
- * @see org.junit.Assert
- * @see org.junit.Test
- * @since GemFire 7.0
- */
-@Category(UnitTest.class)
-public class ThreadUtilsJUnitTest {
-
-  protected Mockery mockContext;
-
-  @Before
-  public void setUp() {
-    mockContext = new Mockery() {
-      {
-        setImposteriser(ClassImposteriser.INSTANCE);
-        setThreadingPolicy(new Synchroniser());
-      }
-    };
-  }
-
-  @After
-  public void tearDown() {
-    mockContext.assertIsSatisfied();
-  }
-
-  @Test
-  public void testGetThreadNameWithNull() {
-    assertNull(ThreadUtils.getThreadName(null));
-  }
-
-  @Test
-  public void testGetThreadNameWithThread() {
-    assertNotNull(ThreadUtils.getThreadName(Thread.currentThread()));
-  }
-
-  @Test
-  public void testInterruptWithNullThread() {
-    ThreadUtils.interrupt(null);
-  }
-
-  @Test
-  public void testInterruptWithNonNullThread() {
-    final Thread mockThread = mockContext.mock(Thread.class, "Interrupted Thread");
-
-    mockContext.checking(new Expectations() {
-      {
-        oneOf(mockThread).interrupt();
-      }
-    });
-
-    ThreadUtils.interrupt(mockThread);
-  }
-
-  @Test
-  public void testIsAlive() {
-    assertTrue(ThreadUtils.isAlive(Thread.currentThread()));
-  }
-
-  @Test
-  public void testIsAliveWithNullThread() {
-    assertFalse(ThreadUtils.isAlive(null));
-  }
-
-  @Test
-  public void testIsAliveWithUnstartedThread() {
-    final Thread thread = new Thread(new Runnable() {
-      public void run() {}
-    });
-    assertFalse(ThreadUtils.isAlive(thread));
-  }
-
-  @Test
-  public void testIsAliveWithStoppedThread() throws InterruptedException {
-    final AtomicBoolean ran = new AtomicBoolean(false);
-
-    final Thread thread = new Thread(new Runnable() {
-      public void run() {
-        ran.set(true);
-      }
-    });
-
-    thread.start();
-    thread.join(50);
-
-    assertFalse(ThreadUtils.isAlive(thread));
-    assertTrue(ran.get());
-  }
-
-  @Test
-  public void testIsWaitingWithNullThread() {
-    assertFalse(ThreadUtils.isWaiting(null));
-  }
-
-  @Test
-  public void testIsWaitingWithRunningThread() {
-    final Thread runningThread = mockContext.mock(Thread.class, "Running Thread");
-
-    mockContext.checking(new Expectations() {
-      {
-        oneOf(runningThread).getState();
-        will(returnValue(State.RUNNABLE));
-      }
-    });
-
-    assertFalse(ThreadUtils.isWaiting(runningThread));
-  }
-
-  @Test
-  public void testIsWaitingWithWaitingThread() {
-    final Thread waitingThread = mockContext.mock(Thread.class, "Waiting Thread");
-
-    mockContext.checking(new Expectations() {
-      {
-        one(waitingThread).getState();
-        will(returnValue(State.WAITING));
-      }
-    });
-
-    assertTrue(ThreadUtils.isWaiting(waitingThread));
-  }
-
-  @Test
-  public void testSleep() {
-    final long t0 = System.currentTimeMillis();
-    final long sleepDuration = ThreadUtils.sleep(500);
-    final long t1 = System.currentTimeMillis();
-
-    assertTrue(t1 > t0);
-    assertTrue(sleepDuration > 0);
-  }
-
-  @Ignore("This is really just testing Thread.sleep(long)")
-  @Test
-  public void testSleepWithInterrupt() throws Throwable {
-    TestFramework.runOnce(new SleepInterruptedMultithreadedTestCase(10 * 1000));
-  }
-
-  protected static class SleepInterruptedMultithreadedTestCase extends MultithreadedTestCase
{
-
-    private final long sleepDuration;
-
-    private volatile Thread sleeperThread;
-    private volatile boolean sleeperWasInterrupted;
-    private volatile long actualSleepDuration;
-
-    public SleepInterruptedMultithreadedTestCase(final long sleepDuration) {
-      assert sleepDuration > 0 : "The duration of sleep must be greater than equal to
0!";
-      this.sleepDuration = sleepDuration;
-    }
-
-    public void thread1() {
-      assertTick(0);
-      sleeperThread = Thread.currentThread();
-      sleeperThread.setName("Sleeper Thread");
-      waitForTick(1);
-      actualSleepDuration = ThreadUtils.sleep(sleepDuration);
-      sleeperWasInterrupted = sleeperThread.isInterrupted();
-      assertTick(2);
-    }
-
-    public void thread2() throws Exception {
-      assertTick(0);
-      Thread.currentThread().setName("Interrupting Thread");
-      waitForTick(1);
-      waitForTick(2);
-      sleeperThread.interrupt();
-      assertTick(2);
-    }
-
-    @Override
-    public void finish() {
-      assertThat(sleeperWasInterrupted).isTrue();
-      assertThat(actualSleepDuration).isGreaterThan(0);
-    }
-  }
-
-}


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
users@infra.apache.org


> Cleanup ThreadUtil
> ------------------
>
>                 Key: GEODE-3936
>                 URL: https://issues.apache.org/jira/browse/GEODE-3936
>             Project: Geode
>          Issue Type: Bug
>            Reporter: Jinmei Liao
>            Priority: Major
>
> It's not useful anymore.



--
This message was sent by Atlassian JIRA
(v6.4.14#64029)

Mime
View raw message