Java线程概念以及三种实现的方式

前言

从本章开始，我们将展开对多线程的学习，多线程的内容比较多，将会挑选主要的类进行分析，本章主要是带大家回顾下线程的基础知识。为了让我们能快速进入状态，先热身下，先来看一道面试题：说说进程和线程的区别？

答：进程是程序的一次执行，是系统进行资源分配和调度的独立单位；进程的创建、切换、销毁会产生大量时间和空间的开销，进程的数量不能太多。线程是进程的一个实体，线程是比进程更小的独立运行的基本单位，线程拥有很少的系统资源，比如：程序计数器、寄存器、栈；进程则占有堆、栈。

1、线程的状态

我们将由一张图，来看看线程由哪些状态

说明：
线程共包括以下5种状态。

1. 新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
   (01) 等待阻塞 – 通过调用线程的wait()方法，让线程等待某工作的完成。
   (02) 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
   (03) 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

2、线程的实现方式

2.1、继承Thread类

下面我们来看一段测试代码：

public class ExtendsThread extends Thread {

    public ExtendsThread(String name){
        super(name);
    }

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

    public static void main(String[] args){
        Thread t1=new ExtendsThread("Thread_1");
        Thread t2=new ExtendsThread("Thread_2");
        t1.start();
        t2.start();
    }
}

结果：

Thread_1
Thread_2

2.2、实现Runnable接口

public class TestRunnable {
    public static void main(String[] args) {
        RunnableImpl runnable1 = new RunnableImpl();
        RunnableImpl runnable2 = new RunnableImpl();
        Thread thread1 = new Thread(runnable1,"thread_1");
        Thread thread2 = new Thread(runnable2, "thread_2");
        thread1.start();
        thread2.start();
    }
}

class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

执行结果：

thread_2
thread_1

2.3、使用Callable和Future接口创建线程

public class ThreadTest {
    public static void main(String[] args) {

       Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
       FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
       for (int i = 0; i < 15; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 2) {
                  Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                  thread.start();                      //线程进入到就绪状态
            }
        }
        System.out.println("主线程for循环执行完毕..");
        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<Integer> {
    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (int i=0; i<8; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}

执行结果：

main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
Thread-0 0
main 9
Thread-0 1
main 10
Thread-0 2
main 11
Thread-0 3
main 12
main 13
main 14
主线程for循环执行完毕..
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
sum = 28

上面的结果永远都是sum=28在最后，那么为什么sum =28会永远最后输出呢？
原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

结束语

本篇先介绍到这，后面将详细介绍Callable和Future接口。

如果你觉得本篇文章对你有帮助的话，请帮忙点个赞，再加一个关注。