多线程的实现方式

线程和进程之间的关系：

一个进程中的线程可以共享代码和数据空间，线程结束，进程不一定结束，但是进程结束，线程一定结束。进程中包含线程，线程是进程的组成部分。

Java中实现多线程的方式有以下3种：

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口（JDK1.5以上）

继承Thread类

一个普通的类继承了Thread类，这个类就被称为具备多线程操作能力的类。具备多线程操作能力的类通常要求重写父类Thread中的run()方法，在run()方法中所编写的代码被称为线程体。

public class TestThread extends Thread {
    @Override
    public void run() {
//        System.out.println("mythread的run方法被重写");
        //编写线程体（线程所执行的代码）
        for(int i=0;i<3;i++){
            int sum=0;
            sum+=i;
            System.out.println(sum);
        }
    }

    //主方法负责Java程序的运行，也成为主线程
    public static void main(String[] args) {
        //创建线程类对象
        TestThread mythread=new TestThread();
        //启动线程
        mythread.start();
        for(int i=0;i<3;i++){
            int sum=0;
            sum+=i;
            System.out.println("===========main方法中的代码"+sum);
        }
    }
}

实现结果

 

 

实现Runnable接口

第二种实现多线程的方式是让类实现Runnable接口，具备多线程操作能力

public class TestRunnbale implements Runnable {

    //必须实现接口中的Run方法



    @Override

    public void run() {

        for(int i=0;i<10;i++){

            int sun=0;

            sun+=i;

            System.out.println("run方法的实现"+sun);

        }

    }



    public static void main(String[] args) {



        TestRunnbale myrunnable=new TestRunnbale();

        //创建线程类对象

        Thread t=new Thread(myrunnable);

        t.start();

        //主线程中的代码

        for(int i=0;i<5;i++){

            System.out.println("main中的代码"+i);

        }

    }

}

实现结果

 

继承Thread类和实现Runnable接口的区别：

Java中的类具有单继承的特点，及如果一个类继承了Thread类，就不能继承其他的类，所以继承Thread类实现多线程有一定的局限性。

通过实现Runnable接口来实现多继承有以下优点：

1. 避免了单继承的局限性；
2. 方便共享资源，同一份资源可以被多个代理访问。

实现Callable接口

Callable接口和Runnable接口的区别：

Callable接口从JDK1.5开始，与通过实现Runnable接口实现多线程相比，实现Callable接口的方式支持泛型。call()方法可以有返回值，而且支持泛型的返回值，比run()方法更轻大的一点是其还可以抛出异常。

任务管理器FutureTask是RunnableFuture接口的实现类，而RunnableFuture接口又继承了Future接口和Runnbale接口，所以任务管理器FutureTaskyeshiRunnable接口的实现类。可通过创建任务管理器类的对象将Callable接口的实现传入，从而实现多线程。

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;



public class TestCallable implements Callable<String>{

    @Override

    public String call() throws Exception {

        //创建一个长度为5的String型的数组

        String [] array={"apple","python","javase","javaee","linux"};

        int random=(int)(Math.random()*4)+1;      //产生一个1-4的随机数

        return array[random];

    }



    public static void main(String[] args) throws InterruptedException, ExecutionException {

        //创建任务

        TestCallable tc=new TestCallable();

        //创建任务管理器，将任务提交给任务管理器

        FutureTask<String> ft=new FutureTask<String>(tc);

        //创建Thread类

        Thread t=new Thread(ft);

        System.out.println("任务是否完成："+ft.isDone());

        //启动线程

        t.start();

        //获取返回值结果

        System.out.println(ft.get());

        System.out.println("任务是否完成："+ft.isDone());

    }

}

实现结果

 

注意：多线程在结果实现时，因为是并发进行的，而且多个线程之间相互抢占资源（资源是有限的），导致的运行结果不是固定唯一的，有可能同样的代码，运行的结果是不相同的。