多线程，就是这么简单

多线程，就是这么简单

文章要点

• 线程是什么
• 线程有什么
• 线程怎么用

线程是什么？

学习线程，首先要先了解几个常用的概念：

• 进程：每个正在系统上运行的程序都是一个进程，一个进程至少包含一个线程，进程可以是整个或者部分程序的动态执行
  • 线程：线程是一组指令的集合，是轻量级的进程，是进程中负责程序执行的执行单元；线程依靠程序，是程序中的顺序控制流，需要使用程序的资源和环境
  • 多线程：简单的理解就是，在一个程序中运行多个任务，其目的是为了更好的利用CPU资源，加快进程的运行速度，增加效率，实现多个线程并发执行

有了多线程，我们就可以实现并发啦

• 并发：通过CPU调度算法，实现宏观上并行，微观上串行的技术

线程有什么？

线程的状态：

我们都知道，线程也有生命周期，整个生命周期有五大基本状态：

• 新建状态：新建一个线程对象
• 就绪状态：创建了对象之后，这个线程如果执行了start()方法，就会位于线程池，等待CPU的使用权，是一种可运行状态
• 运行状态：在就绪状态的基础上获取了CPU使用权，于是执行程序代码，在运作状态

• 阻塞状态：线程因为某种原因失去了CPU的使用权，暂时停止运行，转为阻塞状态，要再次运行则必须经过先转为就绪状态，常见的阻塞有三种情况：

  • 等待阻塞： 正在运行的线程，如果执行了wait()方法，就会被JVM放入等待池中
  • 同步阻塞： 正在运行的线程在获取对象的同步锁失败时，也会被JVM放入等待池
  • 其他阻塞：正在运行的线程若执行了sleep()或者join()方法，或者发出了I/O请求，则线程暂停运行，进入阻塞状态
• 死亡状态：

它们之间的关系，我借用了网上找的一张图片来描述

线程怎么用？

这里，我们细说个所以然

• 创建线程方法一：继承 Thread 类

Thread 类是线程类，本质上是实现了 Runnable 接口，该类的实例就是一个线程，一个线程要执行的任务就写在 run() 方法中，格式：

public abstract void run ()
``` 

**`Thread` 类常用的方法有:**
> - //线程的线程体，通常在  `Thread ` 类的子类中覆盖
> - **public void run()** 
> -  //由 `JVM` 调用线程的 `run()`方法，启动线程开始执行
> - **public void start()** 
> - //返回正在执行的线程对象引用
> - **public static Thread currentThread()**  
> -  //设置线程名
> - **public void setName(String name)** 
> -  //返回线程名
> - **public void getName()** 
> - //使当前正在执行的线程暂时停止执行指定的毫秒时间，需要处理异常
> - **public static void sleep(long millis)**  
> -  //使当前执行的线程暂停执行，允许其他线程执行
> - **public static void yield()** 
> - //中断当前线程
> - **public void interrupt()** 
> - //返回指定线程是否处于活动状态
> - **public boolean isAlive()** 

**创建线程小Demo（继承Thread）：**

/*

• 输入线程程序，查看结果
  */
  class SimpleThread extends Thread {
  public SimpleThread(String str) {

  super(str); // 调用其父类的构造方法
  

  }

  public void run() { // 重写run方法

  for (int i = 0; i < 10; i++) {
      System.out.println(i + " " + getName());
      // 打印次数和线程的名字
      try {
          sleep((int) (Math.random() * 1000));
          // 线程睡眠，把控制权交出去
      } catch (InterruptedException e) {
      }
  }
  System.out.println("DONE! " + getName());
  // 线程代码就完毕啦
  

  }

}

public class TwoThreadsTest {
public static void main(String args[]) {
new SimpleThread(“First”).start();
// 第一个线程的名字为First
new SimpleThread(“Second”).start();
// 第二个线程的名字为Second
}

}

上述代码，首先将类 `SimpleThread` 继承了 `Thread` 类，然后在其覆盖的`run()` 方法（亦即线程体）中加入需要执行的代码，再通过 `new` 方法，创建了两个不同的线程，分别执行他们的 `start()` 方法开始执行

将上面的代码执行几遍，你会发现每次的执行结果都不一样，这进一步说明了多线程的独立性以及达到了异步的目的


-  **创建线程方法二**：实现 `Runnable` 接口

继承`Thread` 类固然是更好理解一点，但是基于Java不支持多继承的特性，这进一步给我们带来了困扰，在这种情况下我们就可以使用第二种方式 `实现Runnable接口`，上面我们说到，继承`Thread`类的本质就是实现了`Runnable` 接口，所以他们的使用方法有很大的相似性，几乎一样

**创建线程小Demo（实现Runnable接口）：**

/*

• 输入线程程序，查看结果
  */
  class SimpleThread implements Runnable {
  public SimpleThread() {

  super(); // 调用其父类的构造方法
  

  }

  public void run() { // 重写run方法

  for (int i = 0; i < 10; i++) {
      System.out.println(i + " " + Thread.currentThread().getName());
      // 打印次数和线程的名字
      try {
          Thread.sleep((int) (Math.random() * 1000));
          // 线程睡眠，把控制权交出去
      } catch (InterruptedException e) {
      }
  }
  System.out.println("DONE! " + Thread.currentThread().getName());
  // 线程代码就完毕啦
  

  }

}

public class TwoThreadsTest {
public static void main(String args[]) {
SimpleThread target = new SimpleThread();
new Thread(target,”First”).start();
// 第一个线程的名字为First
new Thread(target,”Second”).start();
// 第二个线程的名字为Second
}

}

由于没有继承`Thread`类，所以我们要直接对`Thread`进行操作，调用方法或者创建的线程的时候都需要以`Thread`类为基础

-  **创建线程方法三**：实现 `Callable` 接口

使用`Callable`和`Future`接口创建线程，具体是创建`Callable`接口的实现类，并实现`call()`方法，并使用`FutureTask`类来包装`Callable`实现类的对象，且以此`FutureTask`对象作为`Thread`对象的`target`来创建线程。

**创建线程小Demo（实现Callable接口）：**

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

class SimpleThread implements Callable {
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + “ “ + i);
sum += i;
}

    return sum;
}

}

public class TwoThreadsTest {
public static void main(String args[]) {
// 创建对象
Callable simpleThread = new SimpleThread();
// 使用FutureTask来包装对象
FutureTask ft = new FutureTask(simpleThread);
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + “ “ + i);
// FutureTask对象作为Thread对象的target创建新的线程
Thread thread = new Thread(ft);
thread.start();
// 线程代码就完毕啦
System.out.println(“DONE! “);
try {
// 取得新创建的新线程中的call()方法返回的结果
System.out.println(“sum = “ + ft.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}

    }
}

}

整个Demo中几乎找不到我们熟悉的身影，其实，它和继承`Thread`一样，本质上都是实现了`Runnable`接口，我们来看下`FutureTask`的定义

public interface RunnableFuture extends Runnable, Future {
/**

 * Sets this Future to the result of its computation
 * unless it has been cancelled.
 */
void run();

}
`` 所以，虽然我们在使用实现Callable接口的时候，发现实现的是call()方法而不是run()`并且有返回值，其实是一样的