Java多线程--创建线程

1.什么是线程？

我们知道一份代码就是一个程序，当代码运行起来后就是一个进程。进程中可以完成一些我们想要它完成的任务，那么每一个任务就是一个线程。例如我们常用的浏览器，浏览器打开就是开启了一个进程。接着我们可以在浏览器中打开网页窗口，那么一个窗口实际上就是一个线程。当然这只是一个很简单的例子，实际上浏览器除了网页窗口外还要很多线程。

线程基于进程，各自独立。线程共享数据，这使线程之间的通讯非常高效，便捷。

2.创建线程

2.1 线程状态

线程的状态有：1.就绪状态；2.运行状态；3.阻塞状态

就绪状态：线程已经启动，但是没有获得CPU资源，无法运行。

运行状态：线程在就绪状态获得到CPU资源，此时线程就处于运行中。

阻塞状态：造成线程阻塞的因素有很多，此时与CPU资源无关，即使CPU有资源运行线程，线程仍然阻塞。

由以上三种线程的状态定义我们就可以推出以下关系：

首先创建线程，接下来调用start()方法启动线程。线程启动后进入就绪状态，此时线程等待CPU资源以开始运行。线程得到CPU资源进入运行状态，当线程的时间片结束，则线程会返回就绪状态再次等待CPU资源。如此往复，直到线程完成所有任务，此时线程终止。但是线程在运行状态时，可能因为异常或业务要求等等原因会进入阻塞状态。当阻塞状态结束后，却不会返回运行状态，而是进入就绪状态，再次等候CPU资源。

以上的描述可能不利于理解，实际逻辑如图：

2.2 创建线程

了解了线程的状态以及它们之间的关系后，我们先来创建一个线程。Java中我们有一个Thread类，顾名思义就是线程的类。我们创建线程围绕这个类有三种方法

2.2.1 继承Thread类创建线程

Thread类中有一个run()方法，这个方法的内容实际上就是最终的线程所要完成的任务或要执行的代码。为什么说run()方法中的内容是线程最终要执行的代码呢？因为我们的Thread只是一个普通的类，而我们为这个类实例化后得到的也只是一个普通对象。只有调用了这个对象的start()方法后，才能真正启动一个线程，而此时这个线程所执行的代码正是run()方法中的代码。

那么我们就可以通过创建一个类继承Thread类，覆写Thread类的run方法来添加我们所要的代码。通过对我们的类实例化创建线程。

如下代码：

public class MyThreadTest {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //实际上使用start()方法将会运行一个进程，此时这个进程的运行是与main()方法无关而独立的
        //所以线程对象的run方法与main()方法中的打印的执行先后顺序是没有联系的
        myThread.start();
        //这是一个很简单的对象调用方法，此时run()方法的执行是在main()线程中的，要按照正常的执行顺序执行
        myThread.run();
        System.out.println("这是main()方法的打印");
        
    }

}

class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("这是一个线程的run()方法");
    }

}

2.2.2 Runnable接口创建线程

我们查看Thread类的构造方法，可以看到这样一个构造方法：

public Thread(Runnable target)

Runnable是一个接口，实际上Thread类就是一个实现了Runnable接口的类。所以Runnable接口中也有run()方法，又由于Java支持向上转型，所以我们可以创建一个类实现Runnable接口并且实现run()方法，然后给调用Thread类的构造方法，以这个类的实例化对象来作为参数，由此创建线程。

如下代码：

public class MyRunnableTest {

    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);
        thread1.start();
        thread2.start();
        thread3.start();

        Thread thread4 = new Thread(new Runnable() {
            public void run() {
                Thread.currentThread().setName("Thread-Runnable匿名对象线程");
                System.out.println("这是"+Thread.currentThread().getName()+"线程的run方法");
            }
        });
        thread4.start();

        Runnable runnable1 = () -> {
            Thread.currentThread().setName("Thread-Runnable使用Lamdba表达式实例化线程");
            System.out.println("这是"+Thread.currentThread().getName()+"线程的run方法");
        };
        Thread thread5 = new Thread(()->{
            Thread.currentThread().setName("Thread-Runnable使用Lamdba表达式实例化线程");
            System.out.println("这是"+Thread.currentThread().getName()+"线程的run方法");
        });
//        Thread thread5 = new Thread(runnable1);
        thread5.start();
    }

}


class MyRunnable implements Runnable {

    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println("这是" + name + "线程的run方法");
    }
}

2.2.3 Callable接口创建线程

以上两种方式创建的线程最终的代码都是在run()方法中的，而run()方法没有返回值。但是在一些情况下我们是需要有一个返回值的，这是上面的两种创建线程方式就不能满足我们的要求了。此时我们就可以使用Callable接口，它创建的现成的最终的代码是在call()方法中的，而Call方法是可以有返回值的。但是Thread类并没有一个接收Callable类对象的构造方法，此时我们就要借助一个类---FutureTask。我们来看一看FutureTask这个类，它实现了RunnableFuture这个接口，而RunnableFuture接口又继承了Runnable接口。而且，FutureTask这个类又有一个接收Callable接口的构造方法。我们在创建一个类实现Callable接口并且实现call()方法添加我们的代码。那么根据Java向上转型，我们就能够为FutureTask类实例化一个接收实现Callable接口的类对象的对象，最终在将这个对象传入Thread类的构造方法创建线程。

用文字描述可能比较难以理解，我们看一下这个图：

如下代码：

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

public class MyCallableTest {

    public static void main(String[] args) {

        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask,"Thread-1").start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

}

class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("线程"+Thread.currentThread().getName()+"的打印");
        return "线程"+Thread.currentThread().getName()+"返回的数据";
    }

}

以上代码都在我的github上，github链接：https://github.com/nodonotnodo/java/tree/master/thread