内容概要
多线程基础概念
进程
进程是指程序(任务)的执行过程，它是一个动态的概念。
持有资源(共享内存、共享文件)和线程，也就是说进程是资源和线程的载体。
当我们双击执行可执行文件使得Eclipse或者QQ运行起来，这才称为进程。
线程
线程是依赖于进程的执行绪(执行路径/控制单元)，是程序使用CPU的基本单位。
线程是系统中最小执行单元，同一进程中可以有多个线程，线程共享进程的资源。
当我们运行Eclipse之后会进行一些任务，比如进行源代码文本编辑、源代码编译、语法校验，再比如我们的QQ，可以用QQ和你的同伴进行文字的聊天，同时还可以收发文件，所有的这些任务我们都可以将它理解为是线程。
生活例子
再举一个更为生活化的例子，如果把我们的进程比作一个班级，那我们班级的每一个学生可以将他视为一个线程。
这里学生是班级之中的最小单元，构成了班级之中的最小单位，一个班级可以有多个学生，这些学生都使用班级之中共同的桌椅、板凳、书籍、黑板等等资源进行他们的学习生活。
在这个意义上我们说线程是系统中最小执行单元，同一进程中可以有多个线程，线程共享进程的资源。
线程的交互
多个线程需要相互通信才能正确的工作，这种通信我们称之为线程的交互。交互的方式包括互斥与同步。
互斥通常表现在多个线程竞争同一资源，而同步就是协同步调，按预定的先后次序进行运行。
将这个概念类比到班级之中，那就是在同一个班级之内，我们的同学之间要通过相互的协作才能完成某个任务，有时这种协作是需要竞争的，比如班级公共的学习资料是有限的，爱学习的同学需要抢占它，需要竞争。当一个同学使用完了之后下一个同学才能使用，如果正在使用那么其他的同学只能等待。
另一方面我们又需要同步或者协作，就好比班级在节日的时候需要排演节目，全班同学齐心协力相互配合才能将我们的节目完美的呈现在舞台上。这就是线程的交互。
多线程
多线程是指从软件或者硬件上实现多个线程并发执行的技术。简单理解就是同一个进程中有多个线程并发执行。
这多个线程共享该进程资源(堆内存与方法区)，栈内存独立。使用多线程可以提高cpu的使用率，从而提高程序的执行效率。
比如JVM的运行就是多线程的，因为JVM启动时至少启动了垃圾回收线程和主线程。
并发与并行
系统中有多个任务同时存在可称之为“并发”，系统内有多个任务同时执行可称之为“并行”。
并发和并行是既相似又有区别的两个概念，并行是指两个或者多个事件在同一时刻发生，而并发是指两个或多个事件在同一时间间隔内发生。
多个程序同时运行
在我们的电脑上可以同时运行很多个程序，多个程序都是通过cpu来运行的，cpu的执行时间被分为多个等大小的时间片，时间片的时间非常短比如是1ms, 对于cpu来说程序实际是轮流运行的，多个程序是通过随机的抢占cpu时间片来运行，因为时间间隔非常短，所以感官上是多个程序同时运行的，这个称之为cpu时间片的轮转
Java对线程的支持
Java语言对线程的支持主要体现在Thread这个类及Runnable这个接口上，它们都属于java.lang包。
无论是Thread类还是Runnable接口都有一个run方法，这个方法为我们提供了线程实际工作执行的代码。
Runnable接口
- 该接口只有一个方法run()，代表线程入口
- Runnable是java中用于实现线程的接口
- 任何实现线程功能的类都必须实现该接口
Thread类
代表程序中的执行线程类，实现了Runnable接口，位于java.lang包下。该类的常用API如图所示
构造方法说明
常用方法说明
run方法可以将其理解为其他线程的main方法，即该线程的执行入口。
调用start方法会自动调用这个线程的run方法。
线程创建方式
- 创建一个Thread子类的对象
- 创建一个实现Runnable接口的类的对象
继承Thread类
- 自定义线程类继承Thread类
- 重写run方法，run方法内为该线程执行代码。
- 创建线程对象
- 开启线程，即调用start方法
示例：总共5张火车票，通过继承Thread方式，3个窗口共卖出15张，因为成员变量没有共享，为ticketCount加static修饰后则卖出5张。
class MyThread extends Thread{
private static int ticketCount = 5;//一共5张火车票
private String name;//窗口，线程名称
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
while(ticketCount > 0){
ticketCount--;//如果还有票，就卖掉一张
System.out.println(name + "卖了一张票，剩余票数为："+ ticketCount);
}
}
}
//火车站卖票示例
public class TicketsThread {
public static void main(String[] args) {
//创建3个线程，模拟三个窗口卖票
MyThread mt1 = new MyThread("窗口1");
MyThread mt2 = new MyThread("窗口2");
MyThread mt3 = new MyThread("窗口3");
//启动线程，开始卖票
mt1.start();
mt2.start();
mt3.start();
/*执行结果
窗口3卖了一张票，剩余票数为：2
窗口2卖了一张票，剩余票数为：3
窗口2卖了一张票，剩余票数为：0
窗口1卖了一张票，剩余票数为：3
窗口3卖了一张票，剩余票数为：1
*/
}
}
实现Runnable接口
- 自定义Runnable接口的实现类(非线程类)
- 重写run方法，run方法内为该类对象所在线程的执行代码。
- 创建Runnable的实现类对象，使用Runnable的实现类对象创建线程对象
- 开启线程，即调用线程对象的start方法
示例：总共5张火车票，通过实现Runnable接口方式，3个窗口卖出5张票，因为共享了同一个对象的成员变量
class MyRunnable implements Runnable{
private int ticketCount = 5;//一共5张火车票
@Override
public void run() {
while(ticketCount > 0){
ticketCount--;//如果还有票，就卖掉一张
System.out.println(Thread.currentThread().getName() + "卖了一张票，剩余票数为："+ticketCount);
}
}
}
//火车站卖票示例
public class TicketsRunnable {
public static void main(String[] args) {
//创建3个线程，模拟3个窗口卖票
MyRunnable mt = new MyRunnable();
Thread th1 = new Thread(mt, "窗口1");
Thread th2 = new Thread(mt, "窗口2");
Thread th3 = new Thread(mt, "窗口3");
//启动线程，开始卖票
th1.start();
th2.start();
th3.start();
/*
窗口1卖了一张票，剩余票数为：3
窗口3卖了一张票，剩余票数为：2
窗口3卖了一张票，剩余票数为：1
窗口3卖了一张票，剩余票数为：0
窗口2卖了一张票，剩余票数为：3
*/
}
}
以上执行都存在线程安全问题，票数的显示与预期效果可能不一致，可以通过线程同步来解决这个问题。
两种方式比较
线程常用方法详解
线程优先级
- 线程优先级代表了抢占CPU的能力。优先级越高，抢到CPU执行的可能性越大。
- 一般环境下效果不明显，优先级也并非绝对的执行顺序，和很多因素有关比如线程的启动顺序。
- 优先级可以用整数1-10表示，超过范围会抛出异常，线程默认优先级为5
线程优先级方法
线程优先级常量
线程休眠
指定线程休眠一定时间，进入等待状态。在该段时间结束后，线程重新可执行。
sleep()方法示例：
class MyThread implements Runnable{
@Override
public void run() {
for(int i=1;i<=5;i++){
System.out.println(Thread.currentThread().getName()+"执行第"+i+"次！");
try {
//当前线程睡眠1s，此时其他线程可以抢占cpu资源
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class SleepDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t = new Thread(mt);
t.start();
Thread t1 = new Thread(mt);
t1.start();
/*执行结果：线程高概率交替执行,并且执行是有时间间隔的
Thread-0执行第1次！
Thread-1执行第1次！
Thread-0执行第2次！
Thread-1执行第2次！
...
*/
}
}
加入线程
- 等待某个加入的线程终止后再执行，调用方法的线程将获有优先执行的权利。
- 如果不加参数则表示join方法所在的所有线程必须等待调用join方法的线程执行完毕才可以继续执行，否则其他线程等待了指定时间后就会重新和该线程竞争cpu执行权。
- 如果参数m为0则意味着要一直等下去，等同于调用无参的join方法。
join()方法示例：
class MyThread2 extends Thread {
public void run() {
for (int i = 1; i <= 500; i++)
System.out.println(getName() + "正在执行" + i + "次！");
}
}
public class JoinDemo {
public static void main(String[] args) throws InterruptedException {
MyThread2 mt = new MyThread2();
mt.setName("霸道线程");
mt.start();
//mt.join(); //霸道线程执行完500次后主线程才开始执行
mt.join(5); //5毫秒后主线程开始和霸道线程抢占资源执行，结果：主线程在霸道线程执行过程中就执行完毕了
for (int i = 1; i <= 20; i++) {
System.out.println("主线程运行第" + i + "次！");
}
System.out.println("主线程运行结束！");
}
}
线程礼让
调用yield方法的线程会将cpu资源暂时让出来并重新竞争，出现线程交叉执行的概率更大，但是并不意味着调用该方法的线程下次一定不被执行，而是会与其他线程一起重新竞争cpu时间，谁抢到了就执行谁。
yield()方法示例：
class MyThread3 implements Runnable{
@Override
public void run() {
for(int i=1;i<=5;i++){
System.out.println(Thread.currentThread().getName()+"执行第"+i+"次！");
//让出了处理器时间，下次该谁执行还不一定呢！
Thread.yield();
}
}
}
public class YieldDemo {
public static void main(String[] args) {
MyThread3 mt = new MyThread3();
Thread t = new Thread(mt);
t.start();
Thread t1 = new Thread(mt);
t1.start();
/*执行结果：线程高概率交替执行
Thread-0执行第1次！
Thread-1执行第1次！
Thread-1执行第2次！
Thread-0执行第2次！
...
*/
}
}
中断线程
- 如果线程因为调用wait()、join()、sleep(long)及其重载方法而处于阻塞中时，使用interrupt()方法会将其中断状态清除(false)，它还将收到一个InterruptedException
- 如果没有出现阻塞等其他情况，使用interrupt()方法会将该线程的中断状态设置为true
- interrupt()方法并不能停止正在运行的线程，它只能改变中断状态而已
interrupt()方法示例：
public class InterruputThread extends Thread {
public static void main(String[] args) {
InterruputThread thread = new InterruputThread();
System.out.println("starting thread...");
thread.start();
//主线程睡眠3秒
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("interrupting thread...");
//中断线程
thread.interrupt();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("stopping application...");
}
@Override
public void run() {
while (true) {
System.out.println("Thread is running...");
//系统时间休眠 -- 等同于sleep(1000)
long time = System.currentTimeMillis();
while(System.currentTimeMillis() -time < 1000){
//减少屏幕输出的循环
}
/*try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println(this.isInterrupted());
}*/
}
}
}
程序运行结果分析
1.使用while(true) + 系统时间休眠代码 线程并不能终止
2.使用while(!this.isInterrupted()) + 系统时间休眠
线程可以正常退出,即调用interrupt方法后，this.isInterrupted()为true
3.使用while(true) + sleep方法 或者 while(!this.isInterrupted()) + sleep方法
线程不能终止，且会抛出InterruptedException异常，此时打印了this.isInterrupted()值为false
停止线程
- 错误方式：使用stop()方法，stop方法过于暴力，会让当前线程马上停止，后续的逻辑都无法执行，对数据和业务都可能造成不可预估的错误。
- 正确方式：使用退出标志来停止线程，既能保证业务逻辑的完整性，且有时间去执行一些清理工作，使得线程代码变得安全可控。
class MyRunnable implements Runnable {
//volatile保证了线程可以正确的读取其他线程写入的值
//可见性 ref JMM， happens-before原则
//1.定义退出标志变量
volatile boolean keepRunning = true;
@Override
public void run() {
//2.在线程体方法中使用变量
while(keepRunning){
for(int i=0;i<5;i++){
System.out.println("执行业务逻辑" + i);
}
}
System.out.println("执行清理工作");
}
}
//正确停止线程方式
public class StopDemo2 {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread thread = new Thread(mr);
thread.start();
//主线程睡眠，让thread有执行的机会
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//3.停止线程
//如果线程此时阻塞了可以调用interrupt方法进行中断
//thread.stop();
mr.keepRunning = false;
}
}
守护线程
在java中线程有两类，用户线程和守护线程。
用户线程：运行在前台，执行具体的任务。比如程序的主线程、连接网络的子线程等都是用户线程。
守护线程：运行在后台，为其他前台线程服务。
守护线程说明
特点：一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作
应用：数据库连接池中的监测线程、JVM虚拟机启动后的监测线程
最常见的守护线程：垃圾回收线程
如何设置守护线程
可以通过调用Thread类的setDaemon(true)方法来设置当前的线程为守护线程。有几点注意事项
1.setDaemon(true)必须在start()方法之前调用，否则会抛出IlegalThreadStateException异常
2.在守护线程中产生的新线程也是守护线程
3.不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
守护线程示例
演示使用守护线程执行写文件的操作，主线程使用scanner阻塞进程，让守护线程持续运行，一旦主线程获取到键盘输入便会结束阻塞状态，主线程结束运行，守护进程也随之结束，写入过程也就被中断了。
import java.io.File;
import java.io.FileOutputStream;
import java.util.Scanner;
class DaemonThread implements Runnable {
@Override
public void run() {
System.out.println("进入守护线程：" + Thread.currentThread().getName());
try {
writeToFile();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("退出守护线程：" + Thread.currentThread().getName());
}
//写文件操作
private void writeToFile() throws Exception {
File filename = new File("d:" + File.separator + "daemon.txt");
FileOutputStream os = new FileOutputStream(filename, true);
int count = 0;
while (count < 999) {
os.write(("\r\nword" + count).getBytes());
System.out.println("守护线程"+Thread.currentThread().getName()+"向文件中写入了word"+count++);
Thread.sleep(1000);
}
}
}
public class DaemonThreadDemo {
public static void main(String[] args) {
System.out.println("进入主线程：" + Thread.currentThread().getName());
DaemonThread daemonThread = new DaemonThread();
Thread thread = new Thread(daemonThread);
thread.setDaemon(true);
thread.start(); //守护线程不断向文件写入内容
Scanner sc = new Scanner(System.in);
sc.next(); //让主线程阻塞，一旦输入值，则主线程顺序执行并结束，而守护线程也会随之结束
System.out.println("退出主线程：" + Thread.currentThread().getName());
}
}
线程生命周期
线程状态
线程共有五种状态，分别为创建(新建)状态、就绪(可运行)状态、正在运行状态、终止状态和阻塞状态。
状态描述
生命周期图解
