一、线程与进程的关系
关于进程与线程，百度百科上是这样描述的：
进程(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{
/**
* 重写 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 future = new FutureTask(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线程总归下来有五种状态：
新建、就绪、阻塞、运行、死亡
而这里对应的方法却有很多种，具体的关系，我这里准备了一张图：
这张图上面中的方法我会在以后的博客中分享到，这次的分享就到这里，希望大家能够喜欢。
最后
注：若有转载，请标明原处。如若有错，也欢迎小伙伴前来指正。
扫一扫
1340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
