Java多线程详解（如何创建线程）

        嗨喽～小伙伴们我们又见面了，   

        前面一章，我们了解了线程的基本概念，从这一章，我们开始学习如何创建一个线程。总的说来，在java中，有四种创建线程的方式：

1. 继承Thread类

2. 实现Runnable接口

3. 实现Callable接口

4. 使用线程池

        上述四种创建线程的方式中，我们着重介绍 1，2 ，对于 3，4，小伙伴们作为了解即可。下面用代码来实现四种创建方式。

一. 继承Thread类:

         下面的代码中使用了sleep()方法，不太理解的同学可以先放一放，后面我们会详细介绍这个方法。

/**
 *
 * @author sixibiheye
 * @date 2021.08.28
 * @apiNote 继承Thread类
 *
 */
public class Thread1 extends Thread {
    private String name;
    public Thread1(String name){
        this.name = name;
    }
    //需要重写Thread类的run()方法
    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            System.out.println(name+"运行："+i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        //通过创建对象的方式来创建两个线程
        Thread1 thread1_1 = new Thread1("thread1_1");
        Thread1 thread1_2 = new Thread1("thread1_2");
        //启动线程
        thread1_1.start(); //当CPU调度thread1_1时，会执行thread1_1对应的run()方法
        thread1_2.start(); //当CPU调度thread1_2时，会执行thread1_2对应的run()方法
    }
}

        上一章的学习我们知道，调用线程的start()方法后，上述的两个线程就都进入了可运行态，注意此时两个线程均还没有运行。

        只有当CPU调度之后，才能开始执行。至于两个线程到底谁先运行，完全取决于某一刻谁获得了CPU的使用权。因此，程序的运行结果是相对随机的，每一次运行的结果都有可能不同。

        比如，第一次运行结果：

         第二次运行结果：

二. 实现Runnable接口：

        下面的代码中，Thread.currentThread().getName()可以获得当前线程的名字，此外注意导入sleep()方法所在的包：

import static java.lang.Thread.sleep;

/**
 *
 * @author sixibiheye
 * @date 2021.08.28
 * @apiNote 实现Runnable接口
 *
 */
public class Thread2 implements Runnable {
    //仍然需要重写Thread类的run()方法
    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName()+"运行："+i);
            try {
                sleep( 100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        //类似创建对象的方式来创建线程
        Thread2 thread = new Thread2();
        //启动线程
        new Thread(thread,"线程A").start(); //当CPU调度线程A时，会执行线程A对应的run()方法
        new Thread(thread,"线程B").start(); //当CPU调度线程B时，会执行线程B对应的run()方法
    }
}

        小伙伴们可能对上述创建线程的方式有点不太理解，它使用到了一种设计模式-----静态代理模式来创建线程。不太清楚的可以去参考一下我的另一篇博文：

        浅谈java的静态代理模式

        同样的，由于CPU何时调度哪个线程是不确定的，上述方式得到的运行结果也不尽相同，比如第一次运行结果：

        第二次运行结果：

  

 

三. 实现Callable接口：

        实现Callable接口和实现Runnable接口的区别在于，实现Callable接口允许用户自定义返回值和抛出异常，而实现Runnable接口无返回值且不能抛出异常：

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

/**
 * @author sixibiheye
 * @date 2021.08.28
 * @apiNote 实现 Callable 接口
 *
 */

public class Thread3 implements Callable<Integer> {
    private int count3 = 10;
    @Override
    public Integer call() throws Exception{
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName()+"运行：" + count3--);
        }
        return 200;
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建Callable的对象
        Callable<Integer> callable = new Thread3();
        //开始线程(FutureTask类同时实现了Future接口和Runnable接口)
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
        new Thread(futureTask).start();
        //打印返回值
        System.out.println(futureTask.get());
    }
}

        上述实现Callable接口来创建线程的方式只需了解即可。此外Callable接口还可通过线程池来创建线程，与线程池有关的内容，参见我的另一篇博文。

        现阶段我们只需掌握前两种创建方式（继承Thread类，实现Runnable接口）即可。

        最后，我们来对比一下继承Thread类，实现Runnable接口两种创建线程的方式：

​​​​​​​        实现Runnable接口可以实现资源共享，而继承Thread类不行。此外，实现Runnable接口还可以避免Java单继承带来的局限性。

        因此，一般采用实现Runnable接口来实现多线程。

        最后，关于实现Runnable接口可以实现资源共享的说法，小伙伴们可以参见下面一段代码：

import static java.lang.Thread.sleep;
public class Thread2 implements Runnable{
    //票数
    private int count = 15;
    @Override
    public void run() {
        for(int i = 0; i < count; i++){
            System.out.println(Thread.currentThread().getName()+"抢到了第：" + i++ +"张票");
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        new Thread(new Thread2(),"A").start();
        new Thread(new Thread2(),"B").start();
    }

}

        上面代码中的票数count便是一个公共资源，实现Runnable接口可以很轻松地实现资源共享。

        下一章我们将会介绍多线程里必须要解决的一个问题-----线程安全（点击跳转​​​​​​​）。最后喜欢的小伙伴们点个赞鼓励支持一下吧～