要了解多线程，我们首先要了解 程序，进程，线程 这三个概念。
程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期。（如：运行中的微信，运行中的音乐播放器。 程序是静态的，进程是动态的。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
线程(thread) 进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间 并行执行多个线程，就是支持多线程的线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
举个例子：某安全卫士的 源代码 就是 程序
当我们运行这个 程序，也就是打开这个安全卫士件的时候，就可以看作是一个 进程
当我们使用这个 安全卫士 进行 查杀木马 ，查杀木马的时候 就可以看作是一个 线程
而当我们 在查杀木马 的同时， 我们又 进行了 清理磁盘垃圾 ， 这就是一个 进程 同时执行了多个 线程，也就是多 线程 。
若你还没有理解什么是 程序，进程，线程，你也可以看下图：
相信你对 程序，进程，线程 ，有了一定了解。 接下来我们就来说说Java里的多线程。
先来个多线程的快速实现。
同时遍历100以内的所有的偶数//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
//2.重写Thread的run()方法
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
//Thread.currentThread().getName() 这个是用来获取当前线程的名字
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreaadTest {
public static void main(String[] args) {
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
//4.通过此对象调用start() ①启动当前进程 ②调用当前进程的run()
t1.start();
t2.start();
}
}
我们能看到运行结果中，不同于以往（先把 t1 的结果输出，再 输出 t2 的结果），现在 t1 的结果 和 t2 的结果 是交替输出的，这就是多线程。
下面我们来分析一下代码：
我们首先是创建了一个 继承于 Thread 类的子类。
然后，我们重写了Thread类中的 run() 方法， 将我们要执行的操作 放在了重写的 run() 方法中。
接着，我们在主函数中 创建了两个 该子类 的对象 t1 和 t2。
最后，我们用 t1 和 t2 ，分别调用了 start() 方法。
这个start()方法有两个作用，先是启动了当前线程，然后调用了当前线程的run()方法。
t1.start(); 就是先 启动了 t1 这个进程，然后调用了 t1 线程 里的run()方法 (遍历100以内的偶数)
t2.start(); 也是一样的作用。
不同于以往单线程（先执行完 t1 的 run() 方法 ，再执行 t2 的 run() 方法）
现在是多线程（ t1 的 run() 方法 和 t2 的 run() 方***同时进行）
所以我们会看到 t1 和 t2 线程，交替打印输出。
在Java中，多线程的创建方式有 4 种。（前两种是 JDK 5.0 之前的， 后两种是 JDK 5.0 之后新增的）
我们先说 JDK 5.0 之前的两种方式。
方式一：继承Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run()方法 -->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()
（代码如上一样，就不重复贴了）
方式二：实现runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
Thread t2 = new Thread(mThread);
//5.通过Thread类的对象调用start()
t1.start();
t2.start();
}
}方式一 与 方式二 比较
开发中：优先选择 实现Runnable接口的方式
原因：
1.Java是单继承多实现，使用实现Runnable接口的方式没有类的单继承的局限性
2.实现Runnable的方式，更适合处理多个线程有共享数据的情况
方式三：实现Callable接口
1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6.若有返回值，可以调用 get() 方法 获取Callable中call方法的返回值
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadCallable {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.可以获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
实现Callable接口的方式创建多线程比实现Runnable接口的方式有如下优点：
1. call()可以返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的
方式四：使用线程池
1. 提供指定线程数量的线程池 （可按需设置线程池的属性）
2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
3.关闭连接池
class NumerThread implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumerThread1 implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口类的实现
service.execute(new NumerThread()); //execute()适合适用于Runnable
service.execute(new NumerThread1());
// service.submit(); //submit()适合适用于Callable
//关闭连接池
service.shutdown();
}
}
使用线程池的好处：
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不用每次都创建）
3.便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没任务时最多保持多长时间后会终止
更多关于Java多线程的知识，将在后面的文章中继续更新。
京公网安备 11010502036488号