Java中实现多线程的几种方式总结_Java

java实现多线程的几种方式

1）继承thread类

实现的步骤：

1）创建thread类的子类
2）重写run方法
3）创建线程对象
4）启动线程

代码示例：

package com.bobo.thread;

public class threaddemo02 {

    /**
     * 线程的第一种实现方式
     *     通过创建thread类的子类来实现
     * @param args
     */
    public static void main(string[] args) {
        system.out.println("main方法执行了1...");
        // java中的线程 本质上就是一个thread对象
        thread t1 = new threadtest01();
        // 启动一个新的线程
        t1.start();
        for(int i = 0 ; i< 100 ; i++){
            system.out.println("main方法的循环..."+i);
        }
        system.out.println("main方法执行结束了3...");
    }
}

/**
 * 第一个自定义的线程类
 *    继承thread父类
 *    重写run方法
 */
class threadtest01 extends thread{

    @override
    public void run() {
        system.out.println("我们的第一个线程执行了2....");
        for(int i = 0 ; i < 10 ; i ++){
            system.out.println("子线程："+i);
        }
    }
}

注意点：

1）启动线程是使用start方法而不是run方法

2）线程不能启动多次，如果要创建多个线程，那么就需要创建多个thread对象

2）实现runnable接口

在第一种实现方式中，我们是将线程的创建和线程执行的业务都封装在了thread对象中，我们可以通过runable接口来实现线程程序代码和数据有效的分离。

实现的步骤：

1）创建runable的实现类
2）重写run方法
3）创建runable实例对象（通过实现类来实现）
4）创建thread对象，并把第三步创建的runable实例作为thread构造方法的参数
5）启动线程

代码示例：

package com.bobo.runable;

public class runabledemo01 {

    /**
     * 线程的第二种方式
     *     本质是创建thread对象的时候传递了一个runable接口实现
     * @param args
     */
    public static void main(string[] args) {
        system.out.println("main执行了...");
        // 创建一个新的线程  thread对象
        runnable r1 = new runabletest();
        thread t1 = new thread(r1);
        // 启动线程
        t1.start();
        system.out.println("main结束了...");
    }
}

/**
 * 线程的第二种创建方式
 *   创建一个runable接口的实现类
 */
class runabletest implements runnable{

    @override
    public void run() {
        system.out.println("子线程执行了...");
    }
}

实现runable接口的好处：

1）可以避免java单继承带来的局限性

2）适合多个相同的程序代码处理同一个资源的情况，把线程同程序的代码和数据有效的分离，较好的体现了面向对象的设计思想

3）实现callable接口（jdk1.5>=）

前面我们介绍的两种创建线程的方式都是重写run方法，而且run方法是没有返回结果的，也就是main方法是不知道开启的线程什么时候开始执行，什么时候结束执行，也获取不到对应的返回结果。而且run方法也不能把可能产生的异常抛出。

在jdk1.5之后推出了通过实现callable接口的方式来创建新的线程，这种方式可以获取对应的返回结果。

代码示例：

package com.bobo.callable;

import java.util.concurrent.callable;
import java.util.concurrent.futuretask;

public class callabledemo01 {

    /**
     * 创建线程的第三种实现方式：
     *    callable方式
     */
    public static void main(string[] args) throws  exception {
        // 创建一个callable实例
        callable<integer> callable = new mycallable();
        futuretask<integer> futuretask = new futuretask<>(callable);
        // 获取一个线程 肯定是要先创建一个thread对象  futuretask本质上是runable接口的实现
        thread t1 = new thread(futuretask);
        system.out.println("main方法start....");
        t1.start(); // 本质还是执行的 runable中的run方法，只是 run方法调用了call方法罢了
        // 获取返回的结果
        system.out.println(futuretask.get()); // 获取开启的线程执行完成后返回的结果
        system.out.println("main方法end ....");

    }
}

/**
 * 创建callable的实现类
 *    我们需要指定callable的泛型，这个泛型是返回结果的类型
 */
class mycallable implements callable<integer>{

    /**
     * 线程自动后会执行的方法
     * @return
     * @throws exception
     */
    @override
    public integer call() throws exception {
        int sum = 0;
        for(int i = 1 ; i <= 100 ; i ++){
            sum += i;
        }
        return sum;
    }
}

实现runnable接口和实现callable接口的区别：

1）runnable是自从java1.1就有了，而callable是1.5之后才加上去的
2）callable规定的方法是call(),runnable规定的方法是run()
3）callable的任务执行后可返回值，而runnable的任务是不能返回值(是void)
4）call方法可以抛出异常，run方法不可以
5）运行callable任务可以拿到一个future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。