Java并发编程之美——Java线程创建的三种方式以及优缺点总结

超、凢脫俗 2023-05-29 03:35 49阅读 0赞

Java 中有三种线程创建方式， 分别为实现 Runnable 接口的 run 方法， 继承 Thread 类并重写 run 的方法， 使用 FutureTask 方式。  
（1）**继承 Thread 类方式的实现**

/** * <p> * Java 中有三种线程创建方式， 分别为实现 Runnable 接口的 run 方法， 继承 Thread 类并重写 run 的方法， 使用 CallerTask 方式; * </p> * * @author xiaoyi * @date 2019/11/3 */
    public class ThreadTest { 
    
        public static class MyThread extends Thread { 
    
            @Override
            public void run() { 
                System.out.println("I am a child Thread");
                //不能有return
            }
    
            public static void main(String[] args) { 
                //创建线程
                MyThread myThread = new MyThread();
                //启动线程
                myThread.start();
            }
        }
    }

如上代码中的 MyThread 类继承了 Thread 类， 并重写了 ru顶）方法。 在 main 函数里面创建了 个 MyThread 的实例，然后调用该实例的 start 方法启动了线程。 需要注意的是，当创建完 thread 对象后该线程并没有被启动执行， 直到调用了 start 方法后才真正启动了线程。其实调用 start 方法后线程并没有马上执行而是处于就绪状态， 这个就绪状态是指该线程已经获取了除 CPU 资源外的其他资源，等待获取 CPU 资源后才会真正处于运行状态。一旦 run 方法执行完毕， 该线程就处于终止状态。使用继承方式的好处是， 在 run() 方法内获取当前线程直接使用 this 就可以了， 无须使用 Thread.currentThread() 方法不好的地方是 Java 不支持多继承，如果继承了 Thread 类，那么就不能再继承其他类。 另外任务与代码没有分离， 当多个线程执行 样的任务时需要多份任务代码， 而 Runable 则没有这个限制。 下面看实现 Runnable 接口的 run 方法方式

（2）**实现Runnable方法**

/** * <p> * 线程的创建方式二：实现Runnable接口 * </p> * * @author xiaoyi * @date 2019/11/3 */
    public class RunableTask implements Runnable { 
    
        @Override
        public void run() { 
            System.out.println("Runnable: I am a child thread");
            //不能有return
        }
    
        public static void main(String[] args) { 
            RunableTask task = new RunableTask();
            new Thread(task).start();
            new Thread(task).start();
        }
    
    }

**（3）使用FutureTask**

public class CallerTask implements Callable<String> { 
    
        @Override
        public String call() throws Exception { 
            System.out.println("FutureTask: I am a child thread");
            System.out.println("-------------------------------");
            return "hello";
        }
    
        public static void main(String[] args) throws Exception { 
            //创建异步式任务
            FutureTask<String> futureTask = new FutureTask<>(new CallerTask());
            //启动线程
            new Thread(futureTask).start();
    
            try { 
                String result = futureTask.get();
                System.out.println(result);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
    
        }
    }

总结：  
\* 使用继承方式的好处是方便传参， 你可以在子类里面添加成员变量， 通过set 方法设置参数或者通过构造函数进行传递，  
\* 而如果使用Runnable方式， 则只能使用主线程里面被声明为final的变量。 不好的地方是Java不支持多继承， 如果继承了Thread类，  
\* 那么子类不能再继承其他类， 而Runable则没有这个限制。 前两种方式都没办法拿到任务的返回结果， 但是Futuretask方式可以。