Java多线程-三种实现方式

Java多线程-三种实现方式

一、继承Thread类（无返回值、无法抛出异常）

​ 继承Thread类，重写该类的run方法。这种方式实现简单，但是由于单一继承原则，该方式使用的比较少。

1. MyThread类

   package com.izhouy.demothreadpool.thread;
   
   /**
    * @author izhouy
    * @title MyThread
    * @Decription 继承Thread类创建线程
    * @CreateDate 2021/6/30 11:24
    */
   public class MyThread extends Thread {
   
       private int ticket = 5;
   
       @Override
       public void run() {
           for (int i = 0; i < 10; i++) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + ":" + ticket--);
               }
           }
       }
   }
   

2. 测试类

       /**
        * 继承Thread类,实现多线程
        */
       @Test
       void myThreadTest(){
           for (int i = 0; i < 3; i++) {
               new MyThread().start();
           }
           System.out.println("主线程结束");
       }
   

二、实现Runnable接口（无返回值、无法抛出异常）

​ 实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

​ Runnable是可以共享数据的，多个Thread可以同时加载一个Runnable，当各自Thread获得CPU时间片的时候开始运行Runnable，Runnable里面的资源是被共享的，所以使用Runnable更加的灵活。

​ 这种方式可以解决Thread单一继承的问题，通常使用这种方式。

1. MyRunnable

   package com.izhouy.demothreadpool.thread;
   
   /**
    * @author izhouy
    * @title MyRunnable
    * @Decription 实现Runnable接口创建线程
    * @CreateDate 2021/6/30 14:06
    */
   public class MyRunnable implements Runnable{
   
       private int ticket = 5;
   
       @Override
       public void run() {
           for (int i = 0; i < 10; i++) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + ":" + ticket--);
               }
           }
       }
   }
   

2. 测试类

       /**
        * 实现Runnable接口实现多线程
        */
       @Test
       void myRunnableTest(){
           MyRunnable myRunnable = new MyRunnable();
           for (int i = 0; i < 3; i++) {
               new Thread(myRunnable).start();
           }
           System.out.println("主线程结束");
       }
   

三、实现Callable接口（有返回值、可抛异常）

​ 使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

1. MyCallable

   package com.izhouy.demothreadpool.thread;
   
   import java.util.concurrent.Callable;
   
   /**
    * @author izhouy
    * @title MyCallable
    * @Decription 实现Callable接口创建线程
    * @CreateDate 2021/6/30 14:17
    */
   public class MyCallable implements Callable<String> {
   
       private int ticket = 5;
   
       @Override
       public String call() throws Exception {
           for (int i = 0; i < 10; i++) {
               if (ticket > 0) {
                   System.out.println(Thread.currentThread().getName() + ":" + ticket--);
               }
           }
           return Thread.currentThread().getName();
       }
   }
   

2. 测试类

       /**
        * 实现Callable接口实现多线
        * @throws ExecutionException
        * @throws InterruptedException
        */
       @Test
       void myCallableTest() throws ExecutionException, InterruptedException {
           Callable<String> myCallable = new MyCallable();
           List<Future<String>> futures = new CopyOnWriteArrayList<>();
           for (int i = 0; i < 3; i++) {
               FutureTask<String> longFutureTask = new FutureTask<String>(myCallable);
               futures.add(longFutureTask);
               new Thread(longFutureTask).start();
           }
           System.out.println("主线程结束");
           for (Future<String> future : futures) {
               System.out.println("结果:" + future.get());
           }
       }
   

四、三种方式的比较

​ 通过以上的测试结果，我们可以分析出：

1. 在第一种方法中，我们new了3个Thread对象，即三个线程分别执行三个对象中的代码，因此便是三个线程去独立地完成相同的任务；
2. 而在第二种方法中，我们同样也new了3个Thread对象，但只有一个Runnable对象，3个Thread对象共享这个Runnable对象中的代码，因此，便会出现3个线程共同完成一个任务的结果。如果我们new出3个Runnable对象，作为参数分别传入3个Thread对象中，那么3个线程便会独立执行各自Runnable对象中的代码，即3个线程完成各自的任务。
3. 在第二种方法中，由于3个Thread对象共同执行一个Runnable对象中的代码，因此可能会造成线程的不安全，比如可能ticket会输出-1（如果我们System.out…语句前加上线程休眠操作，该情况将很有可能出现），这种情况的出现是由于，一个线程在判断ticket为1>0后，还没有来得及减1，另一个线程已经将ticket减1，变为了0，那么接下来之前的线程再将ticket减1，便得到了-1。这就需要加入同步操作（即互斥锁），确保同一时刻只有一个线程在执行每次for循环中的操作。而在第一种方法中，并不需要加入同步操作，因为每个线程执行自己Thread对象中的代码，不存在多个线程共同执行同一个方法的情况。
4. 第三种方式和第二种方式类似，但是第一种和第二种都不允许声明检查型异常、不能定义返回值，如果需要抛出异常和有返回值则选择第三种方式。
5. 第三种方式需要配合Future对象使用，Callable和Future一个产生结果，一个拿到结果。

通过以上分析，如果不需要抛出异常和返回值，推荐使用第二种（实现Runnable接口），如果需要抛出异常或定义返回值，使用第三种。

• 实现Runnable接口相比继承Thread类有如下优势：
  1. 可以避免由于Java的单继承特性而带来的局限。
  2. 增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
  3. 适合多个相同程序代码的线程区处理同一资源的情况。
• 实现Runnable接口和实现Callable接口的区别：
  1. Callable规定的方法是call(),Runnable规定的方法是run()。
  2. Callable的任务执行后可返回值，而Runnable的任务是不能返回值(是void)。
  3. call方法可以抛出异常，run方法不可以。
  4. 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。
  5. 加入线程池运行，Runnable使用ExecutorService的execute方法，Callable使用submit方法。

五、Future常用方法

Future 表示异步计算的结果。Future接口中有如下方法：

1. 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束

   boolean cancel(boolean mayInterruptIfRunning)
   

2. 任务是否已经取消，任务正常完成前将其取消，则返回 true

   boolean isCancelled() 
   

3. 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true

   boolean isDone()
   

4. 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException

   V get()
   

5. 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException

   V get(long timeout, TimeUnit unit)