今天我们先来聊聊有关线程的话题......

 

一. 线程概述

1. 简单区分程序、进程和线程

程序是指一段静态的代码

进程是指正在执行的程序，将静态的代码运行起来

线程是指正在执行程序的小单元

举个栗子，班级准备大扫除，在大扫除之前，老师在纸上列了一个清单，每个同学都有不同的工作任务，分配好任务之后，每个同学都是有条不紊地完成自己的任务，扫地的同学去扫地，擦黑板的同学去擦黑板，清理桌子的同学清理桌子......在这个例子里，这个清单就是程序，而这个班级的全体同学是一个整体，也就是一个进程，最后，这个班级里面一个个同学就是一个个线程。

---

2. 理解进程

理解线程之前，先简单理解一下进程。进程的三大特征：独立性、动态性、并发性。

独立性：指进程是系统中独立存在的实体，拥有独立的资源（eg：私有的地址空间）。

动态性：这是相对于程序而言的，程序是一段静态的代码，而进程是活动的，拥有自己的生命周期。

并发性：多个进程可以在单个处理器上并发执行，互不影响。

还是上面那栗子，这个班级就是一个进程，他是一个整体，他拥有自己的教室，有自己的班级名字，这里可以体现出独立性。这个班级的全体人员按照的任务清单干活，直至把教室打扫干净（即完成任务），这里可以体现出动态性。并发性呢，首先这个班级不只有一个，还有好多其他的班级，他们也可以打扫他们自己的教室，互不影响。

---

3. 理解线程

线程是进程的执行单元，在程序中，线程是独立的、并发的执行流。

线程的特点：

1. 每个线程有自己的堆栈，自己程序计数器，自己的局部变量，这里体现了线程的独立性。

2. 相同父进程下的所有线程共享进程独立的内存单元（eg：代码段、进程的共有数据），为此可以实现线程间的相互通信。

3. 多个线程之间也可以并发执行，互不影响。

---

4. 多线程 VS 多进程

1. 线程之间可以共享内存，而进程之间不可以。

2. 系统创建线程代价比较小，而且多线程是实现多任务并发比多进程的效率更高。

3. Java语言内置了多线程功能，简化了Java多线程编程。

---

二. 线程的创建和启动

1. 继承Thread类创建线程类

步骤：

1. 定义一个线程类，需继承Thread类。

2. 重写父类的run( )方法,此方法是线程执行体，供cpu自动调用（cpu会用调度策略去处理就绪状态的线程）。

3. 创建线程类的实例对象，调用start( )方法，这个方法告诉cpu这个线程对象进入就绪状态。

package com.hx.thread;
?
// 1.定义一个线程类，需继承Thread类。
public class MyThread1 extends Thread {
    // 2.重写run方法
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) throws Exception {
        // 3.创建线程实例，调用start方法，进入就绪状态，交给cpu
        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "     " + i);
            Thread.sleep(10);
        }
    }
}

---

2. 实现Runnable接口创建线程类

步骤：

1. 定义一个线程类，需实现Runnable接口。

2. 实现接口的run( )方法,此方法是线程执行体，供cpu自动调用（cpu会用调度策略去处理就绪状态的线程）。

3. 创建线程类的实例对象。可是Runnable没有start( )方法，因此需要第4步。

4. 创建一个Thread对象（真正的线程对象），用来包装上面的那个实例对象，然后调用start( )方法。

package com.hx.thread;
?
// 1.定义一个线程类，需实现Runnable接口。
public class MyThread2 implements Runnable {
    // 2.实现接口的run( )方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
?
    public static void main(String[] args) throws Exception {
        // 3.创建线程类的实例对象
        MyThread2 myThread2 = new MyThread2();
        // 4.创建一个Thread对象（真正的线程对象），用来包装上面的那个实例对象，然后调用start( )方法。
        Thread t = new Thread(myThread2);
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "     " + i);
            Thread.sleep(10);
        }
    }
}

---

3. 实现Callable接口创建线程类

步骤：

1. 定义一个线程类，需实现Callable接口。

2. 实现Callable接口的call( )方法，此方法是线程执行体。

3. 创建线程类的实例对象。

4. 创建FutureTask的对象来包装线程类实例对象。

5. 创建Thread的对象来包装Future类的实例对象。

package com.hx.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
?
// 1.定义一个线程类，需实现Callable接口
public class MyThread3 implements Callable {
    // 2.实现Callable接口的call()方法
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThre