update thread (#204)

* update thread

* fixed build on gradle

Author: realDuYuanChao

src/main/java/com/examplehub/basics/thread/CallableExample.java

@@ -2,14 +2,5 @@
 
 import java.util.concurrent.Callable;
 
-public class CallableExample implements Callable<Integer> {
-
-  @Override
-  public Integer call() throws Exception {
-    int sum = 0;
-    for (int i = 1; i <= 100; ++i) {
-      sum += i;
-    }
-    return sum;
-  }
+public class CallableExample {
 }

src/main/java/com/examplehub/basics/thread/DaemonThread.java

@@ -1,11 +1,4 @@
 package com.examplehub.basics.thread;
 
-public class DaemonThread implements Runnable {
-
-  @Override
-  public void run() {
-    while (Thread.currentThread().getState() != Thread.State.TERMINATED) {
-      System.out.println("daemon thread is terminated");
-    }
-  }
+public class DaemonThread {
 }

src/main/java/com/examplehub/basics/thread/DeadLockExample.java

@@ -9,31 +9,31 @@ public static void main(String[] args) {
     Runnable runnableA =
         () -> {
           synchronized (deadLockExample.resourceA) {
-            System.out.println(Thread.currentThread().getName() + "get resourceA");
+            System.out.println(Thread.currentThread().getName() + " get resourceA");
             try {
               Thread.sleep(1000);
             } catch (InterruptedException e) {
               e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() + " is trying to get resourceB");
             synchronized (deadLockExample.resourceB) {
-              System.out.println(Thread.currentThread().getName() + "get resourceB");
+              System.out.println(Thread.currentThread().getName() + " get resourceB");
             }
           }
         };
 
     Runnable runnableB =
         () -> {
           synchronized (deadLockExample.resourceB) {
-            System.out.println(Thread.currentThread().getName() + "get resourceB");
+            System.out.println(Thread.currentThread().getName() + " get resourceB");
             try {
               Thread.sleep(1000);
             } catch (InterruptedException e) {
               e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() + " is trying to get resourceA");
             synchronized (deadLockExample.resourceA) {
-              System.out.println(Thread.currentThread().getName() + "get resourceA");
+              System.out.println(Thread.currentThread().getName() + " get resourceA");
             }
           }
         };

src/main/java/com/examplehub/basics/thread/ExampleRunnable.java

@@ -1,11 +1,4 @@
 package com.examplehub.basics.thread;
 
-public class ExampleRunnable implements Runnable {
-
-  @Override
-  public void run() {
-    for (int i = 0; i < 10; ++i) {
-      System.out.println(Thread.currentThread().getName() + "->" + i);
-    }
-  }
+public class ExampleRunnable{
 }

src/main/java/com/examplehub/basics/thread/ExampleThread.java

@@ -1,10 +1,4 @@
 package com.examplehub.basics.thread;
 
-public class ExampleThread extends Thread {
-  @Override
-  public void run() {
-    for (int i = 0; i < 10; ++i) {
-      System.out.println(getName() + "->" + i);
-    }
-  }
+public class ExampleThread {
 }

src/main/java/com/examplehub/basics/thread/JoinThread.java

@@ -1,10 +1,4 @@
 package com.examplehub.basics.thread;
 
-public class JoinThread implements Runnable {
-  @Override
-  public void run() {
-    for (int i = 0; i < 10; i++) {
-      System.out.println(Thread.currentThread().getName() + i);
-    }
-  }
+public class JoinThread {
 }

src/main/java/com/examplehub/basics/thread/PriorityOfThread.java

@@ -1,9 +1,5 @@
 package com.examplehub.basics.thread;
 
-public class PriorityOfThread implements Runnable {
-  @Override
-  public void run() {
-    System.out.println(
-        Thread.currentThread().getName() + "-> priority = " + Thread.currentThread().getPriority());
-  }
+public class PriorityOfThread {
+
 }

src/main/java/com/examplehub/basics/thread/SleepExample.java

@@ -0,0 +1,4 @@
+package com.examplehub.basics.thread;
+
+public class SleepExample {
+}

src/main/java/com/examplehub/basics/thread/StopThread.java

@@ -1,25 +1,4 @@
 package com.examplehub.basics.thread;
 
-public class StopThread implements Runnable {
-
-  private boolean flag = true;
-
-  @Override
-  public synchronized void run() {
-    while (true) {
-      for (int i = 1; ; ++i) {
-        System.out.println(i);
-        try {
-          Thread.sleep(500);
-        } catch (InterruptedException e) {
-          e.printStackTrace();
-        }
-      }
-    }
-  }
-
-  public void stop() {
-    flag = false;
-    System.out.println("sub thread stopped");
-  }
+public class StopThread {
 }

src/main/java/com/examplehub/basics/thread/TakeMoneyFromAccountExample.java

@@ -0,0 +1,4 @@
+package com.examplehub.basics.thread;
+
+public class TakeMoneyFromAccountExample {
+}

src/test/java/com/examplehub/basics/thread/CallableExampleTest.java

@@ -1,17 +1,47 @@
 package com.examplehub.basics.thread;
 
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
+import java.util.concurrent.*;
+
 import org.junit.jupiter.api.*;
 import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
 
 class CallableExampleTest {
+
   @Test
-  void test() throws ExecutionException, InterruptedException {
+  void testCallable() throws ExecutionException, InterruptedException {
+    class ExampleCallable implements Callable<Integer> {
+
+      @Override
+      public Integer call() throws Exception {
+        int sum = 0;
+        for (int i = 1; i <= 100; ++i) {
+          sum += i;
+        }
+        return sum;
+      }
+    }
+    ExampleCallable exampleCallable = new ExampleCallable();
+    FutureTask<Integer> futureTask = new FutureTask<>(exampleCallable);
+    new Thread(futureTask).start();
+    assertEquals(5050, futureTask.get());
+  }
+
+  @Test
+  void testThreadPool() throws ExecutionException, InterruptedException {
+    class ExampleCallable implements Callable<Integer> {
+
+      @Override
+      public Integer call() throws Exception {
+        int sum = 0;
+        for (int i = 1; i <= 100; ++i) {
+          sum += i;
+        }
+        return sum;
+      }
+    }
     ExecutorService executorService = Executors.newFixedThreadPool(1);
-    Future<Integer> result = executorService.submit(new CallableExample());
+    Future<Integer> result = executorService.submit(new ExampleCallable());
     int callableSum = result.get();
     Assertions.assertEquals(5050, callableSum);
     executorService.shutdown();

src/test/java/com/examplehub/basics/thread/DaemonThreadTest.java

@@ -1,13 +1,31 @@
 package com.examplehub.basics.thread;
 
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 class DaemonThreadTest {
-  //  @Test
+  @Test
   void test() {
-    Thread thread = new Thread(new DaemonThread());
+    class ExampleThread extends Thread {
+      @Override
+      public void run() {
+        assertTrue(Thread.currentThread().isDaemon());
+        while (true) {
+        }
+      }
+    }
+    ExampleThread thread = new ExampleThread();
     thread.setDaemon(true);
     thread.start();
-    for (int i = 0; i < 10; i++) {
-      System.out.println("main thread");
+
+    int sum = 0;
+    for (int i = 1; i <= 100; ++i) {
+      sum = sum + i;
+      assertTrue(thread.isAlive());
+      assertTrue(thread.isDaemon());
     }
+    assertEquals(5050, sum);
   }
 }

src/test/java/com/examplehub/basics/thread/ExampleRunnableTest.java

@@ -6,12 +6,28 @@
 
 class ExampleRunnableTest {
   @Test
-  void testRunnable() {
-    Thread thread = new Thread(new ExampleRunnable());
-    thread.setName("runnable-thread");
-    thread.start();
-    for (int i = 0; i < 10; ++i) {
-      System.out.println(Thread.currentThread().getName() + "->" + i);
+  void testRunnable() throws InterruptedException {
+    class ExampleRunnable implements Runnable {
+      private int sum = 0;
+      @Override
+      public void run() {
+        for (int i = 1; i <= 100; ++i) {
+          sum = sum + i;
+        }
+      }
+      public int getSum() {
+        return sum;
+      }
     }
+    ExampleRunnable exampleRunnable = new ExampleRunnable();
+    Thread thread = new Thread(exampleRunnable);
+    thread.start();
+    thread.join();
+    assertEquals(5050, exampleRunnable.getSum());
+  }
+
+  @Test
+  void testAnonymous() {
+    new Thread(() -> System.out.println("testAnonymous")).start();
   }
 }

src/test/java/com/examplehub/basics/thread/ExampleThreadTest.java

@@ -2,16 +2,99 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 class ExampleThreadTest {
   @Test
-  void test() {
-    ExampleThread exampleThread = new ExampleThread();
-    exampleThread.setName("custom-thread");
-    exampleThread.start();
-    for (int i = 0; i < 10; ++i) {
-      System.out.println(Thread.currentThread().getName() + "->" + i);
+  void test() throws Exception{
+    class ExampleThread extends Thread {
+      private int sum = 0;
+
+      public int getSum() {
+        return sum;
+      }
+
+      @Override
+      public void run() {
+        for (int i = 1; i <= 100; ++i) {
+          sum += i;
+        }
+      }
     }
+    ExampleThread thread = new ExampleThread();
+    thread.start();
+    thread.join(); // main thread wait unit sub thread completed
+    assertEquals(5050, thread.getSum());
+  }
+
+  @Test
+  void testAnonymous() {
+    new Thread(() -> System.out.println("testAnonymous")).start();
+  }
+
+  @Test
+  @Disabled //TODO build fail on gradle platform
+  void testGetThreadId() {
+    new Thread(()->assertTrue(Thread.currentThread().getId() > 1)).start();
+    assertEquals(1, Thread.currentThread().getId());
+  }
+
+  @Test
+  @Disabled //TODO build fail on gradle platform
+  void testGetThreadName() {
+    class ExampleThread extends Thread {
+      public ExampleThread(String name) {
+        super(name);
+      }
+
+      @Override
+      public void run() {
+        assertEquals("sub-thread", getName());
+      }
+    }
+    new ExampleThread("sub-thread").start();
+    new Thread(() -> assertEquals("second-sub-thread", Thread.currentThread().getName()), "second-sub-thread").start();
+    assertEquals("main", Thread.currentThread().getName());
+  }
+
+  @Test
+  void testSumOddEven() throws InterruptedException {
+    class OddSumThread extends Thread {
+      private int sum = 0;
+
+      public int getSum() {
+        return sum;
+      }
+
+      @Override
+      public void run() {
+        for (int i = 1; i <= 99; i += 2) {
+          sum += i;
+        }
+      }
+    }
+    class EvenSumThread extends Thread {
+      private int sum = 0;
+
+      public int getSum() {
+        return sum;
+      }
+
+      @Override
+      public void run() {
+        for (int i = 2; i <= 100; i += 2) {
+          sum += i;
+        }
+      }
+    }
+
+    OddSumThread oddSumThread = new OddSumThread();
+    EvenSumThread evenSumThread = new EvenSumThread();
+    oddSumThread.start();
+    evenSumThread.start();
+    oddSumThread.join();
+    evenSumThread.join();
+    assertEquals(5050, oddSumThread.getSum() + evenSumThread.getSum());
   }
 }