- 一. 背景
- 二. 认识线程(Thread)
- 1. 理解
- 2. 进程和线程的区别(高频面试题)
- 3. 使用代码创建多线程
- 三. 线程的相关操作
- 1. 创建线程
- (1)方法一:继承 Thread 类
- (2)方法二:实现 Runnable 接口
- (3)其它方法
- (4)Thread 的常见构造方法
- (5) Thread 的几个常见属性
- 2. 启动线程
- 3. 中断一个线程
- (1)让线程的入口方法执行完毕(比如Thread.run)
- (2)使用Thread 的 interrupt方法来中断线程
- 4. 等待一个线程- jion()
- 5. 获取当前线程的引用
- 6. 休眠当前线程
- 四. 线程的状态
- 五. 线程安全
- 1. 线程不安全的原因
- (1)原子性
- (2)可见性
- (3)有序性
- 六. synchronized 关键字
- 1. 修饰方法
- 2. 修饰代码块
- 七. volatile 关键字
- 八. 对象等待集
- 1. wait()方法
- 2. notify ——唤醒一个线程
- 3. notifyAll —— 唤醒所有线程
- 九. 多线程案例
- 1. 单例模式
- 2. 阻塞队列
- 3. 线程池
- 十. 常见的所策略
- 1. 乐观锁 VS 悲观锁
- 2. 读写锁
- 3. 重量级锁和轻量级锁
进程是为了实现并发编程的效果,但是为了追求更高的效率就引入了线程。创建 / 销毁一个进程,开销比较大.(进程管理着一些系统分配的资源,申请/释放这些资源不是一个简单的事情)因此就希望能够更高效,更轻量的完成并发编程,因此引入了线程。
线程也被称为“轻量级进程”,每个线程就对应到一个“独立的执行流”,在这个执行流里就能完成一系列的指令,多个线程,就有了多个”执行流”,就可以并发的完成多个系列的指令了。
二. 认识线程(Thread)进程是系统分配资源的最小单位,线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。每个进程至少有一个线程存在,即主线程。
进程和线程的关系:
一个进程包含了多个线程。一个进程其实从系统这里申请了很多的系统资源,进程统一对这些资源进行管理,这个进程内的多个线程,共享了这些资源。
进程是具有“独立性”一个进程挂了,不会影响到其他进程。
线程则不是这样,如果一个线程坏了,就会影响到整个进程的工作。
当我们创建新的进程之后,意味着需要消耗更多的系统资源,在执行进程的时候,目的是为了提高效率(更充分的利用CPU资源)如果是并发的,只有一个CPU执行,效率是有限的;如果是并行的,就可以利用两个CPU效率就更快,实际操作系统执行的时候,到底是并发还是并行,完全取决于调度器的工作。
为了进一步的降低开销,把多进程改成单进程,多线程。创建线程的开销比创建进程的开销小。当线程数目提高,整体的效率确实可能会提高,但是也不是越多越好,当线程数目达到一定的情况之下,继续增加线程,
非但难以提高效率,反而还会降低效率。一旦线程数量太多,就会“拥挤不堪”,这个时候,多个线程为了竞争CPU资源就会占多更多的开销(线程多了,调度的开销也变大了)。因此应该通过“测试”的方法找到一个比较合适的线程数的值。
但是,当一个线程除了问题,就会影响整个进程,造成线程安全问题。
2. 进程和线程的区别(高频面试题)- 进程包含线程的:一个进程可以包含一个线程,也可以包含多个线程~
- 进程是资源分配的基本单位,线程是系统调度执行的基本单位
- 进程和进程之间,是相互独立的。进程A挂了,不会影响到进程B;同一个进程的若干个线程之间,共享着一些资源(内存资源),如果某个线程出现异常,可能会导致整个进程终止,因此其他线程也就无法工作了。
在 Java 中,使用 Thread 类来表示线程。Thread 类是 JVM 用来管理线程的一个类,换句话说,每个线程都有一个唯一的 Thread 对象与之关联。
- 创建一个类继承自Thread;
- 重写Thread的run方法,在新的run里面编写线程要执行的执行流,具体是啥任务;
- 创建子类实例;
- 调用子类的start方法。
class MyThread extends Thread {
@Override
public void run() {
// 线程要执行的任务代码。
// 此处的 run 方法就对应新线程的"执行流"
while (true) {
System.out.println("这是新线程!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test {
public static void main1(String[] args) {
//没有创建其他线程,此时其实也是有一个线程来作为 main 方法执行流
System.out.println("hello world");
// 创建 MyThread 实例,并且开启线程执行。
MyThread myThread = new MyThread();
myThread.start();
while (true) {
System.out.println("这是主线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- run方法,是在start方法内部进行调用的;
- start和run都是Thread类的方法~
- 子类的run是重写的方法,执行的方式是利用“多态”。
myThread.start();
此处的 start 方法就会尝试执行,先创建一个线程在线程内部调用 this.run。此时的 run 到底执行父类的方法还是子类的方法取决于this的指向。
注意:
- 线程是系统中的概念,Java中为了方便操作线程,通过Thread类来表示;
- 不同的系统上,对于线程提供的API是不一样,Java中都通过Thread 类来包装好了;
- Java中的一个Thread对象就和操作系统内部的一个线程是——对应的。
通过继承 Thread 来创建一个线程类,好处是 this 代表的就是当前线程,不需要通过 Thread.currentThread() 来获取当前线程的引用。
代码如上。
(2)方法二:实现 Runnable 接口通过实现 Runnable 接口,把 Runnable 接口的实例赋值给Thread。
Runnable本质上还是要搭配 Thread 来使用,只不过和直接继承Thread相比,换了一种指定任务的方式而已。Runnable仅仅是定义一个要执行的任务,也可以搭配其他的类来使用。这种方式和直接继承 Thread 的方式差别不大,如果非要比较高下,认为 Runnable 这种方式更好一点。能够让线程对象本身,和线程要执行的任务,更加的“解耦合”。
重写的 run 方法定义一个要执行的任务,run=>运行,runnable =>可运行的,Runnable 接口表示一个可以运行的东西,具体就通过run方法来表示运行的实际代码。
class MyTask implements Runnable {
@Override
public void run() {
while (true) {
System.out.println("hello");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
// 通过Runnable接口来完成
Runnable myTask = new MyTask();
Thread t = new Thread(myTask);
t.start();
}
}
(3)其它方法
通过匿名Thread类来创建线程(本质上同方法一):
// 通过Thread的匿名内部类来实现
Thread t = new Thread() {
@Override
public void run() {
System.out.println("hello");
}
};
t.start();
通过匿名 Runnable类来创建线程(本质上同方法二):
// 通过 Runnable 的匿名内部类来实现
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
t.start();
匿名函数往往只是指定一个任务,把这个任务交给某个其他的代码来执行。
使用lambda表达式来创建线程:
// 通过lambda表达式来创建线程
Thread t = new Thread(() -> {
System.out.println("hello");
});
t.start();
只创建一两个线程,就不需要用到线程池.线程比较多,才需要用线程池。
(4)Thread 的常见构造方法| 方法 | 说明 |
|---|---|
| Thread() | 创建线程对象 |
| Thread(Runnable target) | 使用 Runnable 对象创建线程对象 |
| Thread(String name) | 创建线程对象,并命名 |
| Thread(Runnable target, String name) | 使用 Runnable 对象创建线程对象,并命名 |
| 【了解】Thread(ThreadGroup group,Runnable target) | 线程可以被用来分组管理,分好的组即使线程组,这个目前我们了解即可 |
| 属性 | 获取方法 |
|---|---|
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否是后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
- ID 是线程的唯一标识,不同线程不会重复;
- 名称是各种调试工具用到,易于区分;
- 状态表示线程当前所处的一个情况;
- 优先级高的线程理论上来说更容易被调度到;
- 关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后,才会结束运行。
- 是否存活,即简单的理解,为 run 方法是否运行结束了。
一个线程,如果不是守护线程(后台线程)[默认]意味着当主线程结束(main方法执行完毕之后),该线程仍然会继续执行,进程仍然存在;如果把线程设为守护线程,意味着当主线程结束(main方法执行完毕之后),该线程就不会继续执行了,进程退出。
2. 启动线程启动线程必须要调用 start 方法。
start是Thread类的一个关键方法,start的功能就是“让操作系统内核,真正创建一个线程来执行”。虽然 Java 中的 Thread 实例和系统中的线程是——对应的关系,但是两者的生命周期不是完全一样。
调用start ,线程才会被执行。run方法只是一个普通的方法调用,不涉及到创建新线程。而且,run 方法是由 start 方法内部来调用的。
3. 中断一个线程 (1)让线程的入口方法执行完毕(比如Thread.run)public class ThreadDemo6 {
static boolean isRunning = true;
public static void main(String[] args) {
Thread t = new Thread() {
@Override
public void run() {
while (isRunning) {
System.out.println("hello");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t.start();
// 让主线程 sleep 5秒,然后把刚才的标志位给修改成 false
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
isRunning = false;
System.out.println("让线程停止工作");
}
}
(2)使用Thread 的 interrupt方法来中断线程
针对线程代码做出了改变:
a)把while 里面判定的标记位改成了基于Thread.currentThread().islnterrupted();
b)把catch 里面的代码,加一个break。
public class ThreadDemo7 {
public static void main(String[] args) {
Thread t = new Thread() {
@Override
public void run() {
// while 条件本质上还是期望让线程的任务方法能够执行结束
while (!Thread.currentThread().isInterrupted()) {
System.out.println("hello");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
// break 表示具体线程是否要结束,还是根据线程自身的方法来决定的~
break;
}
}
}
};
t.start();
try {
Thread.sleep(5*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("让线程结束!");
t.interrupt();
}
}
调用 interrupt方法来进行中断的时候,可能涉及到两种情况:
1)如果当前线程内部执行的逻辑不涉及到sleep这样的等待,此时就会通过这个标记位来进行退出。Thread.interrupted() 表示清除中断标志,Thread.currentThread().isInterrupted() 表示不清除中断标志;
2)如果当前线程内部执行的逻辑已经进入wait / join / sleep 了,此时就会触发一个InterruptedException,通过catch 捕获到异常,再继续决定如何处理。
注意:通过 thread 对象调用 interrupt() 方法,只是通知该线程应该停止运行,并不是一定被终止。
4. 等待一个线程- jion()当我们创建多个线程之后,每个线程都是一个独立的执行流,这些线程每个线程执行的先后顺序都是不确定的,完全取决于操作系统的调度。
Thread 的 join方法起到的效果是等待某个线程结束,谁调用 join 就等着前面的方法结束后再执行。如果被等待的线程已经执行完毕,此时调用join就不会阻塞了。
join的典型用法:如,多线程下载数据。
5. 获取当前线程的引用Thread currentThread();
这个就是获取到当前线程对象的引用,在哪个线程中调用,就获取到哪个线程对象的引用.
关于获取线程实例:
- 如果线程是通过创建Thread子类,并重写run的方式来创建的话,此时在run方法中,使用this,就能直接找到该线程对象的引用(currentThread 也同样能使用);
- 如果线程是通过Runnable 或者lambda 的方式来创建的话,就不能用this,就只能用currentThread()。
当执行sleep的时候,就是让线程“休眠”。
举例说明:用pid 表示字段;用 tid 表示线程 id。
系统内核中有一个专门的“等待队列”还有一个专门的“就绪队列”。CPU执行的时候是挑就绪队列中的线程来执行的。没有调用sleep时,这些线程都是随时可能被调度到CPU上执行的;如果调用了sleep,就会把对应的task struct(线程)放到等待队列里。时间到了之后,把这个线程的task struct 放回就绪队列,至于这个线程何时去CPU上执行,取决于调度器。
问:等待队列中的线程可能有好多个,这些线程谁应该先出队列,先回到就绪队列中呢?
答:和设定的等待时间相关,这个等待队列不是一个简单的先进先出队列,而是一个“优先级队列”。
线程通常有 5 种状态:创建、就绪、运行、阻塞和死亡状态。
“状态”反应的是“当前的线程正在干啥”,对于调试多线程程序是比较有帮助的。
Thread.State 表示线程的状态是一个枚举类型
这里所谈的状态,指的是Java Thread类的状态,能一定程度反应出操作系统中的线程的状态,但也不绝对。
- NEW:Thread对象刚创建,还没有在系统中创建线程.相当于,任务交给线程了,但是线程还没开始执行.
- RUNNABLE:线程是一个准备就绪的状态,随时可能调度到CPU上执行,或者正在CPU上执行~(线程的task struct在就绪队列中)
- BLOCKED/WAITING/TIMED_WAITING:线程当前已经阻塞了.(此处这三个状态对应着不同的阻塞原因)
- TERMINATED:系统中的线程结束了(入口方法执行完毕).Thread 对象还没销毁。
当多个线程访问同一个对象时,若不用进行额外的同步控制或其他的协调操作,调用这个对象的行为都可以获得正确的结果, 我们就说这个对象是线程安全的。
由于线程是一个“抢占式”执行的过程(这些线程谁先执行,谁后执行,不确定,完全取决于系统的调度器),由于不确定性太多,就可能会导致多个线程访问同一个资源的时候,出现bug,也就出现了线程安全问题。
1. 线程不安全的原因 (1)原子性原子性指一个操作中 CPU 不可中途暂停,要么全部执行完毕,要么都不执行。
(2)可见性当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能立刻看见修改的值。
(3)有序性程序的执行顺序,按照代码的先后顺序执行。加锁(sychronized) 会保证顺序不会被重排; volatile 本身包含禁止指令重排的语义。这 2 个方法都可以保证行车安全。
由于以上的特性没有被遵守,才会出现线程不安全,具体总结为:
- 线程的抢占式执行过程(内核实现的,程序员无法改变)
- 多个线程,修改同一个变量;
- 修改操作不是原子的(保证操作的原子性,是保证线程安全问题的主要手段!!!)
- 内存可见性。
- 指令重排。为了让程序跑的更快,调整了执行的顺序。单线程的话问题不大,多线程就容易出现问题。
为了保证线程安全,引入 sychronized 关键字(监视器锁),即加锁,也称之为”同步锁“。保证在同一时刻, 被修饰的代码块或方法只会有一个线程执行,以达到保证并发安全的效果。
synchronized功能就是保证操作的原子性,同时禁止指令重排序和保证内存可见性。
1. 修饰方法使用synchronized就相当于给操作新增了两个指令:LOCK、UNLOCK。
synchronized public void increase() {
count++;
}
调用方法就加锁,方法结束就解锁。
通过 LOCK 和 UNLOCK 就把LOAD、ADD、SAVE这三个指令给打包成了一个原子的操作(中间不能被打断,不能被其他线程穿插)。
synchronized 也能禁止编译器进行“内存可见性”和“指令重排序“的优化(编译器看到这个synchronized关键字,就不敢轻举妄动)。
但是付出的代价就是程序运行的效率降低了。
2. 修饰代码块public void increase() {
synchronized (this) {
count++;
}
}
如果两个线程竞争同一个锁对象(尝试对同一个对象加锁,此时就会出现一个竞争成功,其他
等待的情况),如果两个线程竞争不同的锁,两个线程都能成功获取到锁。
进行加锁操作就必须明确的搞清楚,到底这个锁是针对“哪个对象”加的,到底这个锁能不能竞争成功。
七. volatile 关键字volatile 起到的效果也是辅助保证线程安全,volatile能够禁止指令重排序,保证内存可见性,但是不保证原子性。在这种一个线程写,一个线程读的场景下,使用volatile 就可以一定程度的保证线程安全,就不必要非得用synchronized(synchronized太重了)
如果是两个线程都要写,这个时候,volatile无能为力,还是得synchronized 登场了。
八. 对象等待集对象等待集起到的效果,就是协调多个线程之间执行的先后顺序。
1. wait()方法其实wait()方法就是使线程停止运行。
wait内部做了三件事~
- 释放锁;
- 等待其他线程的通知;
- 等通知来了之后,重新尝试获取锁。
notify 通知某个线程从wait 中醒来。notify 也是要放到synchronized 中使用,调用notify方法之后,代码并不会立即释放锁,而是在执行完当前的 synchronized 之后才释放锁,同时等待中的线程就尝试重新竞争这个锁。
3. notifyAll —— 唤醒所有线程 九. 多线程案例 1. 单例模式在代码中有些对象只应该有一个实例,就称为“单例”,是一种设计模式。数据库的DataSource就应该是一个单例。在实际开发中还有一些负责加载数据到内存的类,也应该是单例(这样的类往往要持有几个G,几十个G的内存)。
单例模式相当于从语法角度,强制某个类只能有一个实例。
单例模式的实现,主要依托于static关键字(被static修饰的成员,静态成员)。
两种风格的单例模式:
- 1.饿汉模式
- 2.懒汉模式
一般认为懒汉模式更好(但是不绝对,主要还是看场景)懒汉模式要更高效一些。
两种洗碗风格~
1.吃完饭,立刻洗碗~(饿汉模式).吃饭用了4个碗,洗碗也洗4个
2.吃完饭,先不洗,把碗放着.等下顿吃饭之前,再洗(懒汉模式).下顿饭用几个碗,就洗几个。
其中,饿汉模式安全,懒汉模式存在线程安全问题。
线程安全的单例模式,涉及到的要点主要是3点!!
1.加锁(在合适的位置加锁,保证把if和new都包裹起来,同时也不要范围太大)
2.双重if(保证需要加锁的时候才加锁,一旦初始化完毕,就都是读操作了,就不必加锁了)
3.volatile保证外层if读操作,读到的值都是内存中最新的值。
阻塞:
1.这个队列是线程安全的(内部进行了加锁控制)
2.当队列满的时候,往里插入元素,此时就会阻塞…一直阻塞到队列不满的时候才会完成插入.
当队列空的时候,从队列里取元素,此时也会阻塞.….一直阻塞到队列不为空的时候才完成取元素操作.
在实际的开发中,线程的创建和销毁,开销太大,为了解决这个问题,就引入了线程池。把一些线程提前创建好,用的时候从池子里取一个线程就用,用完了不是销毁线程,而是放回池子里
线程池的本质是:把本来应该由内核态完成的东西,交给用户态来完成。
线程池内部要有哪些结构:
1.描述一个任务,就使用Runnable即可,只需要知道任务做啥,不需要知道任务啥时候执行;
2.组织很多任务,使用阻塞队列来保存当前的所有任务;
3.有一些线程,来负责执行阻塞队列中的任务,让这些线程从阻塞队列中取任务并执行.如果阻塞队列为空,就等待;
4.还需要有一个List把当前线程都保存起来,方便管理。
乐观锁: 这个锁认为出现锁竞争的概率比较低.(当前场景中,线程数目比较少,不太涉及竞争,就偶尔竞争一下);
悲观锁: 这个锁认为出现锁竞争的概率比较大.(当前场景中,线程的数目比较多,和可能涉及竞争)。
这是一种特殊的锁,把读操作和写操作分开了。
普通的锁提供两个操作:加锁,解锁
读写锁提供了三个操作:读加锁,写加锁,解锁。
能够进一步降低锁冲突的概率.
注意:
- 读加锁和读加锁之间,不需要互斥.
- 写加锁和写加锁之间,需要互斥.
- 读加锁和写加锁之间,需要互斥.
单纯会从工作量上来区分:
重量级锁,工作量更多,消耗的资源更多,锁更慢;
轻量级算,工作量更少,消耗的资源更少,锁更快.
基于CAS实现的轻量级锁,在加锁的时候遇到冲突,不会涉及到用户态和内核态的切换。直接尝试重新获取锁。



