Java多线程实现的四种方式

最新推荐文章于 2024-09-23 22:36:07 发布

Akita·wang

最新推荐文章于 2024-09-23 22:36:07 发布

阅读量147

点赞数

分类专栏： java相关文章标签： java 多线程接口

本文链接：https://blog.csdn.net/qq_19168521/article/details/113874125

版权

java相关专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细介绍了Java实现多线程的四种方式：继承Thread类、实现Runnable接口、使用Callable和FutureTask以及通过线程池。分别展示了每种方式的代码示例和运行结果，并分析了有返回值和无返回值的区别。最后提到了Executor框架，包括ExecutorService、Callable、Future接口和线程池的工厂方法。

摘要由CSDN通过智能技术生成

Java多线程实现的方式有四种

1.继承Thread类，重写run方法

2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target

3.通过Callable和FutureTask创建线程

4.通过线程池创建线程

前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果

后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

方式1：继承Thread类的线程实现方式如下：

public class ThreadDemo01 extends Thread{
    public ThreadDemo01(){
        //编写子类的构造方法，可缺省
    }
    public void run(){
        //编写自己的线程代码
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ 
        ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
        threadDemo01.setName("我是自定义的线程1");
        threadDemo01.start();       
        System.out.println(Thread.currentThread().toString());  
    }
}

程序结果：
Thread[main,5,main]
我是自定义的线程1

线程实现方式2：通过实现Runnable接口，实现run方法，接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数，通过调用start()方法启动线程

public class ThreadDemo02 {

    public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start(); 
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
    }   
}

程序运行结果：

main

Thread-0–>我是通过实现接口的线程实现方式！

线程实现方式3：通过Callable和FutureTask创建线程

a:创建Callable接口的实现类，并实现Call方法

b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值

c:使用FutureTask对象作为Thread对象的target创建并启动线程

d:调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}

class Tickets<Object> implements Callable<Object>{

    //重写call方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

程序运行结果：
main
Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

线程实现方式4：通过线程池创建线程

public class ThreadDemo05{

    private static int POOL_NUM = 10;     //线程池数量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //关闭线程池
        executorService.shutdown(); 
    }   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  

    }  
}

程序运行结果：

通过线程池方式创建的线程：pool-1-thread-3

通过线程池方式创建的线程：pool-1-thread-4

通过线程池方式创建的线程：pool-1-thread-1

通过线程池方式创建的线程：pool-1-thread-5

通过线程池方式创建的线程：pool-1-thread-2

通过线程池方式创建的线程：pool-1-thread-5

通过线程池方式创建的线程：pool-1-thread-1

通过线程池方式创建的线程：pool-1-thread-4

通过线程池方式创建的线程：pool-1-thread-3

通过线程池方式创建的线程：pool-1-thread-2

ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，还有Future接口也是属于这个框架，有了这种特征得到返回值就很方便了。