Java多线程以及Java线程的三种创建方式

1.进程与线程

            进程：是计算机中资源分配的最小单位。计算机中每个应用程序启动时，os会开启一个进程供该应用使用。例如当你打开QQ时，QQ这个应用程序就被启动了，在这个启动过程中就有进程的创建。当然QQ是支持 多进程的应用，意思就是你可以多次点击QQ，而且每次都会伴随一个QQ登录界面的出现。既然有支持多进程的应用程序，自然也就有支持单进程的，比如任务管理器，无论你点击多少次任务管理器，它都会弹出上次生成的界面。而任务管理器可以看到我们计算机中所有的进程。

            这是任务管理器打开的界面，默认显示的是所有进程，因为进程是计算机中资源分配的最小单位，所以我们可以看到右边画圈的地方会显示该进程占用的计算机资源

                线程:是计算机中可以运行的最小单位。其实线程就是对进程的进一步细分，一个进程中可以有多个线程，这多个线程会共享进程中的资源，当计算机给进程分配资源后，线程可以享用进程中的资源。而java是支持多线程的语言，其实意思就是，当java程序运行时，其实这个java程序就是一个进程，只有获取到cpu的进程才可以运行，而多线程实则就是运行中的java程序，也就是计算机中的进程进一步划分成多个线程来完成任务，当然，java程序运行时，默认会创建一个主线程也就是main线程，其实就是我们常写的main方法来执行我们的程序，如果我们没有在main方法中开启新的线程，默认就是单线程运行。

2.java中线程的三种创建方式

         首先，在java中万物皆对象，所以线程自然有一个线程类（Thread），这个类是java中线程相关的类。所以我们开启新线程离不开Thread类。这里就不介绍源码了，感兴趣的可以自己研究一下。

第一种，自定义线程类继承Thread类或直接new Thread类。

import java.util.Random;

public class Main{
    /*
    * 自定义线程类继承 Thread类
    * 重写 run 方法
    * 必须重写run方法，这里不解释原因，这涉及到源码。这里是重点，
一定要记住必须重写run方法，这里的run方法其实就是线程创建后会自动执行的任务
    * 这里这个自定义类可以不用加static,我这里加上只是为了测试，
因为静态方法只能访问静态变量。
    * */
    static class MyThread extends Thread {

        /*
        * 这里的run方法，其实就是当开启新线程时，这个线程所要执行的任务，
会自动调用，具体原理得看源码
        * */
        @Override
        public void run (){
            System.out.println(13123);
        }
    }

    public static void main(String[] args) {
        /*
        * 上面只是定义了一个自定义线程类，想要在main线程中开启新的线程，必须有一个线程对象
        * 有了这个线程对象，这个线程目前处于new状态，只有通过start方法才会进入Runable阶段，才会开始运行
        * 这两个状态其实是os中进程和线程的状态，不过在java中有所区别，这里不详细介绍*/
        MyThread myThread = new MyThread();
        myThread.start();



        /*
        * 这里也可以直接new 一个线程对象
        * 这个类有个构造方法的参数是Runnable，所以可以直接传一个Runnable接口的实现类，
或者匿名内部类
        * 直接传一个Runnable接口的实现类
        * 当然，第一行也只是创建了线程对象，想要让其运行，必须调用start方法
        * */
        Thread thread = new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(new Random().nextInt(100));
                    }
                }
        );
        thread.start();


    }
}

        当然，这里不推荐使用第一种方式创建线程，因为java是单继承，一旦继承了Thread类，那你这个自定义的类就不可以继承其他类了，局限性较大，这里推荐第二种或者第三种方式

第二种，自定义线程类实现Runnable接口        

        这里实际上就是把上面那个自定义类 extends Thread 换成 implements Runnable，并重写run方法，但在创建线程对象时会和上面那种有些许区别。其实这里的自定义类只是一个任务类，这个类有线程创建时要执行的任务，也就是run方法里面执行的内容，而我们只需创建一个线程也就是Thread类对象，并把我们的任务类交给这个对象就可以了。

import java.util.Random;

public class Main{
    static class MyThread implements Runnable {

        @Override
        public void run (){
            System.out.println(13123);
        }
    }

    public static void main(String[] args) {

        /*
        * 这里首先要创建自定义的类，它实现了Runnable接口
        * Runnable这个接口其实我们第一种方法就已经接触过了
        * 它是Thread类中构造函数中的一个参数，是一个任务
        * 这里要记住，线程类是Thread类，只能通过Thread开启新线程
        * 所以这里我们仍需创建一个Thread类来接受我们的自定义类
        * */
        MyThread myThread = new MyThread();

        Thread thread = new Thread(myThread);
        thread.start();

    }
}

      第三种，自定义线程类实现Callable<?>

               这里这种方式其实也是自定义一个任务类，和第二种类似，只不过这个线程执行这个任务后可以支持返回一个返回值。

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Main{
    /*
    * 实现Callable<?>接口，里面的问号是线程执行完后要返回的内容
    * 重写call()方法，返回值是?类型,当然这个call方法和run方法类似
    * 都是线程创建后自动执行的方法，但是区别在于，run方法没有返回值
    * */
    static class MyThread implements Callable<String> {

        @Override
        public String call() throws Exception {
            return "121";
        }
    }

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

        /*
        * 这里之所以把我们创建的任务类交给FutureTask类
        * 是因为Thread类的构造函数中只支持Runnable参数
        * 而FutureTask类实现了Runnable接口，并且它的构造函数里有Callable参数
        * 所以需要FutureTask对象来过渡，其实这也算一种异步处理，具体不详解
        * 而通过FutureTask类中的get方法可以获取我们自定义任务类中的返回值*/
        MyThread myThread = new MyThread();
        FutureTask f = new FutureTask<>(myThread);

        Thread thread = new Thread(f);

        Object o = f.get();

    }
}