Java线程知识：一、对Java线程的初步认识

一、线程与进程的关系

---

关于进程与线程，百度百科上是这样描述的：

进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。

线程（thread） 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

简单的总结一下，就变成了下面的结果：

进程（Process）： 程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源。

线程（thread） ： CPU调度的最小单位，必须依赖进程而存在。

也就是说 线程与进程的关系，就像玄幻小说中虫族的母体和子体一样，子体离开了母体便不能存活。线程亦是如此，必须依赖于进程而存在。

二、Java线程的启动方式

---

关于Java的线程，我们首当其冲的会想到java.lang.Thread类，这是一种最简单的创建线程的方式，我们只需要通过继承Thread类就可以实现：

/**
 * @author cai
 * 通过继承Thread类的方式
 */
private static class UserThread extends Thread{

    /**
     * 重写  Thread 类的  run() 方法
     */
    @Override
    public void run() {
        System.out.println("this is a thread for extends Thread");
    }
}

这里，我们重写了Thread类中的run()方法，并打印一条语句来表示线程的启动方式，现在我们来测试一下：

public static void main(String[] args) {

    // 继承Thread类的方式
    Thread thread = new UserThread();
    thread.start();
}

控制台的打印结果：

this is a thread for extends Thread

从打印结果可以看出，我们的线程正常的启动，中间没有出现意外。除了这种方式之外，JDK内部又给我们提供了一个接口类：java.lang.Runnable，同样，我们也可以通过实现该接口，重写run()方法来启动一个新的线程：

/**
 * @author cai
 * 通过实现Runnable接口的方式
 */
private static class UserRunnable implements Runnable{

    /**
     * 重写  Runnable 类的  run() 方法
     */
    @Override
    public void run() {
        System.out.println("this is a thread for implements Runnable");
    }
}

这里我们同样打印一句话来表示此线程的启动方式，现在来测试一下：

public static void main(String[] args) throws  {
    // 实现Runnable接口的方式
    // 这里注意：所有线程的启动，都必须通过调用Thread类中start()方法来实现
    Runnable runnable = new UserRunnable();
    new Thread(runnable).start();
}

相信上面的代码，小伙伴们都能看懂（多注意一下第二行的注释，这是重点），现在来看看控制台的打印结果：

this is a thread for implements Runnable

同理，这里的线程也正常的启动了。但看到这里，小伙伴们可能就会产生疑问，为什么JDK要多此一举，提供了一种Thread类后，为什么还要提供Runnable接口类呢？

在这里给有这个疑惑的小伙伴们答疑下：

因为Java是单继承，只能继承一个类，不能继承多个类。而在我们某些实际的业务中，我们可能需要继承一个类来处理逻辑业务，那么就不能再继承Thread类来处理线程相关的操作了。所以JDK又为我们提供了一个实现Runnable接口的方式，而且在Java中，一个类是可以实现多个接口的，这样我们在使用第二种方式处理线程就不会有顾忌了。(这里比较有意思的是：Thread类实现了Runnable接口，有兴趣的小伙伴可以去看一下源码。)

那么除了上面的两种方式之外，Java是否提供了第三种方式呢？答案是肯定的，从JDK1.5开始，JDK为我们提供了一个新的接口类：java.util.concurrent.Callable，我们可以通过实现这个接口来启动一个新得线程，而这种方式与实现Runnable接口来启动线程所不同的是，它会带有一个返回值，我们来看一下代码：

/**
 * @author cai
 * 通过实现Callable接口的方式
 * 带返回值
 */
private static class UserCallable implements Callable<String>{

    /**
     * 重写  Callable 类的  run() 方法
     * @return
     * @throws Exception
     */
    @Override
    public String call() throws Exception {
        return "this is a thread for implements Callable(return String).";
    }
}

测试一下：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 实现Callable接口的方式   带返回值
    UserCallable callable = new UserCallable();
    FutureTask<String> future = new FutureTask<String>(callable);
    new Thread(future).start();
    System.out.println(future.get());
}

我们这里将返回值打印一下：

this is a thread for implements Callable(return String).

可以看出，我们的线程正常的启动，没有问题。

那么看了以上三种Java线程的启动方式，相信肯定有很多小伙伴会好奇，如果我要中止一个线程，我需要怎么做呢？让我们来一起看看吧。

三、Java线程的中止

---

怎样让一个正在运行的线程安全的停止工作呢？这里有两种方法：

1、线程自然的终止：程序正常的执行完或者抛出未处理的异常。

程序正常的执行完就不必再说，以上的代码都属于此类，我们来看一看抛出未处理异常的情况，这里我们将上述实现Runnable接口来启动线程的代码修改一下：

/**
 * @author cai
 * 通过实现Runnable接口的方式
 */
private static class UserRunnable implements Runnable{

    /**
     * 重写  Runnable 类的  run() 方法
     */
    @Override
    public void run() {
        // 重点加了这样的一行代码
        int i = 10 / 0;
        System.out.println("this is a thread for implements Runnable");
    }
}

这里我们加了一行代码，小伙伴们应该都可以看懂，这行代码是必定会抛出异常的，但我们又没有对异常进行处理，现在来看一下控制台的打印结果：

Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
	at com.cai.thread.create.NewThread$UserRunnable.run(NewThread.java:39)
	at java.lang.Thread.run(Thread.java:748)

从结果可以看出，程序运行到了int i = 10 / 0这里就停止了，并没有打印出下一行的结果，由此可见，线程到了这里便停止了，没有再走下去。

2、调用JDK为我们提供的一系列方法

stop()，resume(),suspend(),interrupt(),isInterrupted(),interrupted()这些方法都是JDK为我们提供的，但是``stop()，resume(),suspend()`已经不建议使用了，原因如下：

stop() : 会导致线程不会正常的释放资源，“恶意”的中断当前正在运行的线程，不管线程的逻辑是否完整。

suspend()与resume() : 极易造成公共的同步对象的独占，使得其他线程无法访问公共同步对象，产生死锁。（这个例子以后在讲线程锁的时候会解释。）

我们先来看一下调用stop()的例子：

/**
 * @author cai
 *  调用 stop() 方法的例子
 */
private static class UserRunnable implements Runnable{

    @Override
    public void run() {
        try {
            // 让此线程休眠1秒钟
            Thread.sleep(1000);
        }catch (Exception e){
            // 异常 捕获处理
        }
        // 此处不会运行，控制台不会打印
        // 若实际开发中，这里要处理一个很重要的业务逻辑，那么这里就会有很大的问题。
        // 所以不建议使用
        System.out.println("代码到此处不会运行");
    }
}

public static void main(String[] args) throws InterruptedException {
    Runnable runnable = new UserRunnable();
    Thread thread = new Thread(runnable);
    thread.start();
    // 强行中止线程
    // 从这里可以看出，JDK已经不建议使用stop()方法了，添加了@Deprecated注解
    thread.stop();
}

我这里将测试代码也一并贴了上去，可以在代码的注释中得到相关的结果。讲完这些，我们来看看剩下的三个方法：interrupt(),isInterrupted(),interrupted()

interrupt()：调用此方法会中断一个线程，但并不是强行关闭这个线程，只是先给这个线程打个招呼，同时将线程的中断标志位设置为true，线程是否中断，由线程本身决定。

isInterrupted()：判断当前的线程是否处于中断状态（返回true或者false）。

interrupted()：静态方法，判断当前的线程是否处于中断状态，同时将中断的标志位设置为false。

注意：如果方法中抛出了InterruptedException异常，那么线程的中断标志位会被复位成false，如果确实需要中断线程的操作，我们需要在catch语句中再次调用interrupt()方法。

解释完了，直接上代码吧：

/**
 * @author cai
 * 调用 interrupt(),isInterrupted(),interrupted() 方法的例子
 */
private static class UserThread extends Thread{

    // 给线程一个名字，创建对象时赋值
    public UserThread(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        // 获得线程的名字
        String threadName = Thread.currentThread().getName();
       try {
           // @2
           System.out.println(threadName+" flag is " + isInterrupted());
           // 休眠一秒钟   需要捕获异常 InterruptedException  @3
           Thread.sleep(1000);
       }catch (InterruptedException e){
           // 打印一下  isInterrupted（） 的状态  @4
           System.out.println(threadName+" catch interrput flag is " + isInterrupted());
           // 调用 interrupt() 方法  中断线程操作  @5
           interrupt();
       }
        // 打印线程的名字  @6
        System.out.println(threadName+" interrput flag is " + interrupted());
        // @7
        System.out.println(threadName+" interrput flag is " + isInterrupted());
    }
}

public static void main(String[] args) throws InterruptedException {
    // interrupt(),isInterrupted(),interrupted()  演示
    Thread thread = new UserThread("caiThread");
    thread.start();
    // @1
    thread.interrupt();
}

这里为了方便解释，我分了步骤：

1、@1 的位置调用的interrupt()方法，所以这里的标志位是true，所以 @2 的位置打印结果为true。

2、@3 位置的sleep方法会抛出InterruptedException异常，我这里捕获了，在看之前的理论，抛出此异常，标志位会重置为false，所以@4 这里的打印结果为false。

3、@5 位置再次调用了interrupt()，又把标志位改为了false，所以 @6 这里打印的结果为true，但是这里注意的是，@6 调用了interrupted()这个静态方法，所以标志位又变为了false，所以@7 打印的结果为false。

控制台打印结果：

caiThread catch flag is true
caiThread catch interrput flag is false
caiThread interrput flag is true
caiThread interrput flag is false

小伙伴们可以通过对比结果、代码和解释一起看，相信还是很容易明白的。

对线程的了解再多一点点

---

Java线程总归下来有五种状态：

新建、就绪、阻塞、运行、死亡

而这里对应的方法却有很多种，具体的关系，我这里准备了一张图：

这张图上面中的方法我会在以后的博客中分享到，这次的分享就到这里，希望大家能够喜欢。

最后

---

注：若有转载，请标明原处。如若有错，也欢迎小伙伴前来指正。