并行：同一时刻，多任务同时进行
多任务分别进行

一、线程相关概念

1.程序

是为完成特定任务、用某种语言编写的一组指令的集合。
简单的说:就是我们写的代码

2.进程

（1）进程指的就是运行中的程序，比如我们使用QQ,就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统就会为迅雷分配新的内存空间。

（2）进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态过程：有它自身的产生、存在和消亡的过程

3.线程

（1）线程由进程创建的，是进程的一个实体

（2）一个进程可以拥有多个线程
（例：正在下载的任务可以下载多个文件）

4.其他相关概念

（1）单线程：同一个时刻，只允许执行一个线程

（2）多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

（3）并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。一个任务就是一个进程
（同一时刻，多任务同时进行）

（4）并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。

二、线程使用

1.创建线程的两种方式

1.1 继承Thread类，重写run方法

说明：

• Thread类中的run()是实现的Runnable接口run()，在run()方法中写上自己的业务逻辑，然后调用start()方法就可以启动这个线程，run()方法会被自动调用。
• 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行。这时主线程和子线程是交替执行的。
• 如果主线程在子线程之前结束，子线程也会正常执行并不会因为主线程的结束而结束
• 子线程也可以启动自己的子线程

例：

package com.hspedu.threaduse;
/*** @author 韩顺平* @version 1.0* 演示通过继承 Thread 类创建线程*/
public class Thread01 {public static void main(String[] args) throws InterruptedException {//创建 Cat 对象，可以当做线程使用Cat cat = new Cat();//老韩读源码/*(1)public synchronized void start() {start0();}(2)//start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现//真正实现多线程的效果， 是 start0(), 而不是 runprivate native void start0();*/cat.start();//启动线程-> 最终会执行 cat 的 run 方法//cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行//说明: 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行//这时 主线程和子线程是交替执行.. System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 mainfor(int i = 0; i < 60; i++) {System.out.println("主线程 i=" + i);//让主线程休眠Thread.sleep(1000);}}
}//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*@Overridepublic void run() {if (target != null) {target.run();}}
*/class Cat extends Thread {int times = 0;@Overridepublic void run() {//重写 run 方法，写上自己的业务逻辑while (true) {//该线程每隔 1 秒。在控制台输出 “喵喵, 我是小猫咪”System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());//休眠 1 秒 ctrl+alt+ttry {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if(times == 80) {break;//当 times 到 80, 退出 while, 这时线程也就退出.. }}}
}

1.1.1为什么使用start()，而不直接调用方法

Cat cat = new Cat();//老韩读源码/*(1)public synchronized void start() {start0();}(2)//start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现//真正实现多线程的效果， 是 start0(), 而不是 runprivate native void start0();*/cat.start();//启动线程-> 最终会执行 cat 的 run 方法//cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行

1.2 实现Runnable接口，实现run方法

说明：

• java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时就不能通过继承Thread类方法来创建线程了。
• java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
• 该方式不能通过直接调用start()来启动线程，需要创建Thread对象，再把实现了Runnable的对象放入Thread，通过Thread对象来调用start()方法

例子：

public class Thread02 {public static void main(String[] args) {Dog dog = new Dog();//创建Thread对象，把 dog对象(实现Runnable),放入ThreadThread thread = new Thread(dog);thread.start();}
}class Dog implements Runnable { //通过实现Runnable接口，开发线程int count = 0;@Overridepublic void run() {while (true) {System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());//休眠1秒try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (count == 10) {break;}}}
}

模拟了一个极简的Thread类

//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {private Runnable target = null;//属性，类型是 Runnable@Overridepublic void run() {if (target != null) {target.run();//动态绑定（运行类型）}}public ThreadProxy(Runnable target) {this.target = target;}public void start() {start0();//这个方法是真正实现多线程方法}public void start0() {run();}
}

1.3继承 Thread和实现 Runnable 的区别

• 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
• 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制。
  （建议使用Runnable接口）

2.线程终止退出

（1）当线程完成任务后，会自动退出。

（2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

例子：启动一个线程T，在主线程中通过控制变量值去停止线程

public class ThreadExit_ {public static void main(String[] args) throws InterruptedException {T t1 = new T();t1.start();//如果希望main线程去控制t1 线程的终止, 必须可以修改 loop//让t1 退出run方法，从而终止 t1线程 -> 通知方式//让主线程休眠 10 秒，再通知 t1线程退出System.out.println("main线程休眠10s...");Thread.sleep(10 * 1000);t1.setLoop(false);}
}class T extends Thread {private int count = 0;//设置一个控制变量private boolean loop = true;@Overridepublic void run() {while (loop) {try {Thread.sleep(50);// 让当前线程休眠50ms} catch (InterruptedException e) {e.printStackTrace();}System.out.println("T 运行中...." + (++count));}}public void setLoop(boolean loop) {this.loop = loop;}
}

三、线程常用方法

1.第一组

1.1 细节

• 线程优先级范围
  Thread类中有三个静态常量来表示优先级

    /*** The minimum priority that a thread can have.*/public final static int MIN_PRIORITY = 1;//最小优先级/*** The default priority that is assigned to a thread.*/public final static int NORM_PRIORITY = 5;//正常优先级/*** The maximum priority that a thread can have.*/public final static int MAX_PRIORITY = 10//最大优先级

2 第二组

3.用户线程和守护线程

（1）用户线程：也叫工作线程，当线程的任务执行完结束

（2）守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

（3）常见的守护线程：垃圾回收机制

例子：将一个线程设置为守护线程

  thread.setDaemon(true);thread.start();//需要先设置，再启动

四、线程生命周期

1.线程的七种状态

JDK 中用 Thread.State 枚举表示了线程的几种状态
线程可以处于以下状态之一(可通过thread.getState()查看线程状态)：

• NEW：new,尚未启动的线程处于此状态。

• RUNNABLE：runnable可执行状态,在Java虚拟机中执行的线程处于此状态。
  （可细分为Ready准备执行状态和Running正在执行状态）

• BLOCKED：blocked,被阻塞等待监视器锁定的线程处于此状态。

• WAITING：waiting,正在等待另一个线程执行特定动作的线程处于此状态。

• TIMED_WAITING：timed_waiting,正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

• TERMINATED：terminated己退出的线程处于此状态。

2.线程状态转换示意图

五、线程的同步

任何同一时刻，只允许一个线程访问并操作数据

1.线程同步机制

（1）在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就需要使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

2. 实现同步具体方法-synchronized

1.同步代码块

synchronized (类名.class){//得到对象的锁，才能操作同步代码
//需要被同步代码；
}

2.同步方法

public synchronized static void m (String name){
//需要被同步的代码
}

六、互斥锁

1.基本介绍

（1）Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

（3）关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

（4）同步的局限性：导致程序的执行效率要降低

（5）静态同步方法的锁为当前类本身

（6）非静态同步方法的锁可以是当前对象this,也可以是其他对象(但必须是同一个对象)

2. 注意事项

七、死锁

1.基本介绍

2.理解

当A线程拿到了B线程的所需要的锁，B线程拿到了A线程的所需要的锁，A线程必须把B线程的所需要的锁交给B，B才能执行，B线程必须把A线程的所需要的锁交给A，A才能执行，这样就会导致死锁

八、释放锁

1.会释放锁的操作

1. 当前线程的同步方法、同步代码块执行结束。

   案例：上厕所，完事出来

2. 当前线程在同步代码块、同步方法中遇到break、return。

   案例：没有正常的完事，经理叫他修改bug,不得已出来

3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。

   案例：没有正常的完事，发现忘带纸，不得已出来

4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

   案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

2.不会释放锁的操作

1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep0、Thread.yieldO方法暂停当前线程的执行，不会释放锁。

   案例：上厕所，太困了，在坑位上眯了一会

2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用