1.相关概念
-
程序(program):为完成特定任务,用某种语言编写的
一组指令的集合
。即指一段静态的代码
,静态对象。 -
进程(process):程序的一次执行过程,或是正在内存中运行的应用程序。
每个进程都有一个独立的内存空间,系统运行一个程序即是一个进程从创建、运行到消亡的过程。(生命周期)
程序是静态的,进程是动态的
进程作为操作系统调度和分配资源的最小单位
(亦是系统运行程序的基本单位),系统在运行时会为每个进程分配不同的内存区域。
现代的操作系统,大都是支持多进程的,支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。
-
线程(thread):进程可进一步细化为线程,是程序内部的
一条执行路径
。一个进程中至少有一个线程。
一个进程同一时间若并行
执行多个线程,就是支持多线程的。
线程作为CPU调度和执行的最小单位
。
一个进程中的多个线程共享相同的内存单元,它们从同一个堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患
。
不同的进程之间是不共享内存的。
进程之间的数据交换和通信的成本很高。
线程调度:
分时调度:
所有线程轮流使用
CPU 的使用权,并且平均分配每个线程占用 CPU 的时间。
抢占式调度:
让优先级高
的线程以较大的概率
优先使用 CPU。如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。
多线程程序的优点:
-
提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
-
提高计算机系统CPU的利用率
-
改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
并行(parallel):指两个或多个事件在同一时刻
发生(同时发生)。指在同一时刻,有多条指令
在多个CPU
上同时
执行。
并发(concurrency):指两个或多个事件在同一个时间段内
发生。即在一段时间内,有多条指令
在单个CPU
上快速轮换、交替
执行,使得在宏观上具有多个进程同时执行的效果。
2.创建和启动线程
-
Java语言的JVM允许程序运行多个线程,使用
java.lang.Thread
类代表线程,所有的线程对象都必须是Thread类或其子类的实例。 -
Thread类的特性
-
每个线程都是通过某个特定Thread对象的run()方法来完成操作的,因此把run()方法体称为
线程执行体
。 -
通过该Thread对象的start()方法来启动这个线程,而非直接调用run()
-
要想实现多线程,必须在主线程中创建新的线程对象。
-
方式1:继承Thread类
Java通过继承Thread类来创建并启动多线程的步骤如下:
-
定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务
-
创建Thread子类的实例,即创建了线程对象
-
调用线程对象的start()方法来启动该线程
注意:
-
如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式。
-
run()方法由JVM调用,什么时候调用,执行的过程控制都有操作系统的CPU调度决定。
-
想要启动多线程,必须调用start方法。
-
一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出以上的异常“
IllegalThreadStateException
”。
方式2:实现Runnable接口
Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法
步骤如下:
-
定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
-
创建Runnable实现类的实例,并以此实例作为Thread的target参数来创建Thread对象,该Thread对象才是真正 的线程对象。
-
调用线程对象的start()方法,启动线程。调用Runnable接口实现类的run方法。
通过实现Runnable接口,使得该类有了多线程类的特征。所有的分线程要执行的代码都在run方法里面。
在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,然后调用Thread对象的start()方法来运行多线程代码。
实际上,所有的多线程代码都是通过运行Thread的start()方法来运行的。因此,不管是继承Thread类还是实现 Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。
说明:Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。 而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。
对比两种方式:
联系
Thread类实际上也是实现了Runnable接口的类。
区别
-
继承Thread:线程代码存放Thread子类run方法中。
-
实现Runnable:线程代码存在接口的子类的run方法。
实现Runnable接口比继承Thread类所具有的优势
-
避免了单继承的局限性
-
多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
-
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
3.多线程的生命周期
Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下一些状态:
JDK1.5之前:5中状态
线程的生命周期有五种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。
1.新建
当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。此时它和其他Java对象一样,仅仅由JVM为其分配了内存,并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征,程序也不会执行它的线程体run()。
2.就绪
但是当线程对象调用了start()方法之后,就不一样了,线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器,当然,处于这个状态中的线程并没有开始运行,只是表示已具备了运行的条件,随时可以被调度。至于什么时候被调度,取决于JVM里线程调度器的调度。
注意:
程序只能对新建状态的线程调用start(),并且只能调用一次,如果对非新建状态的线程,如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。
3.运行
如果处于就绪状态的线程获得了CPU资源时,开始执行run()方法的线程体代码,则该线程处于运行状态。如果计算机只有一个CPU核心,在任何时刻只有一个线程处于运行状态,如果计算机有多个核心,将会有多个线程并行(Parallel)执行。
当然,美好的时光总是短暂的,而且CPU讲究雨露均沾。对于抢占式策略的系统而言,系统会给每个可执行的线程一个小时间段来处理任务,当该时间用完,系统会剥夺该线程所占用的资源,让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会,而在选择下一个线程时,系统会适当考虑线程的优先级。
4.阻塞
当在运行过程中的线程遇到如下情况时,会让出 CPU 并临时中止自己的执行,进入阻塞状态:
-
线程调用了sleep()方法,主动放弃所占用的CPU资源;
-
线程试图获取一个同步监视器,但该同步监视器正被其他线程持有;
-
线程执行过程中,同步监视器调用了wait(),让它等待某个通知(notify);
-
线程执行过程中,同步监视器调用了wait(time)
-
线程执行过程中,遇到了其他线程对象的加塞(join);
-
线程被调用suspend方法被挂起(已过时,因为容易发生死锁);
当前正在执行的线程被阻塞后,其他线程就有机会执行了。针对如上情况,当发生如下情况时会解除阻塞,让该线程重新进入就绪状态,等待线程调度器再次调度它:
-
线程的sleep()时间到;
-
线程成功获得了同步监视器;
-
线程等到了通知(notify);
-
线程wait的时间到了
-
加塞的线程结束了;
-
被挂起的线程又被调用了resume恢复方法(已过时,因为容易发生死锁);
5.死亡
线程会以以下三种方式之一结束,结束后的线程就处于死亡状态:
-
run()方法执行完成,线程正常结束
-
线程执行过程中抛出了一个未捕获的异常(Exception)或错误(Error)
-
直接调用该线程的stop()来结束该线程(已过时)
JDK1.5及之后:6种状态
-
NEW(新建)
:线程刚被创建,但是并未启动。还没调用start方法。 -
RUNNABLE(可运行)
:这里没有区分就绪和运行状态。因为对于Java对象来说,只能标记为可运行,至于什么时候运行,不是JVM来控制的了,是OS来进行调度的,而且时间非常短暂,因此对于Java对象的状态来说,无法区分。 -
Teminated(被终止)
:表明此线程已经结束生命周期,终止运行。 -
重点说明,根据Thread.State的定义,阻塞状态分为三种:
BLOCKED
、WAITING
、TIMED_WAITING
。-
BLOCKED(锁阻塞)
:在API中的介绍为:一个正在阻塞、等待一个监视器锁(锁对象)的线程处于这一状态。只有获得锁对象的线程才能有执行机会。-
比如,线程A与线程B代码中使用同一锁,如果线程A获取到锁,线程A进入到Runnable状态,那么线程B就进入到Blocked锁阻塞状态。
-
-
TIMED_WAITING(计时等待)
:在API中的介绍为:一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。-
当前线程执行过程中遇到Thread类的
sleep
或join
,Object类的wait
,LockSupport类的park
方法,并且在调用这些方法时,设置了时间
,那么当前线程会进入TIMED_WAITING,直到时间到,或被中断。
-
-
WAITING(无限等待)
:在API中介绍为:一个正在无限期等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。-
当前线程执行过程中遇到遇到Object类的
wait
,Thread类的join
,LockSupport类的park
方法,并且在调用这些方法时,没有指定时间
,那么当前线程会进入WAITING状态,直到被唤醒。-
通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒;
-
通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒;
-
通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
-
通过Thread类的join进入WAITING状态,只有调用join方法的线程对象结束才能让当前线程恢复;
-
-
-
说明:当从WAITING或TIMED_WAITING恢复到Runnable状态时,如果发现当前线程没有得到监视器锁,那么会立刻转入BLOCKED状态。
4.线程安全问题及解决
当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,若多个线程只有读操作
,那么不会发生线程安全问题。但是如果多个线程中对资源有读和写
的操作,就容易出现线程安全问题。
1、局部变量不能共享
2、不同对象的实例变量不共享
3、静态变量是共享的
4、同一对象的实例变量共享
5、抽取资源类,共享同一资源对象
同步机制解决线程安全问题
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,Java中提供了同步机制 (synchronized)来解决。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
同步机制解决线程安全问题的原理
同步机制的原理,其实就相当于给某段代码加“锁”,任何线程想要执行这段代码,都要先获得“锁”,我们称它为同步锁。因为Java对象在堆中的数据分为分为对象头、实例变量、空白的填充。而对象头中包含:
-
Mark Word:记录了和当前对象有关的GC、锁标记等信息。
-
指向类的指针:每一个对象需要记录它是由哪个类创建出来的。
-
数组长度(只有数组对象才有)
哪个线程获得了“同步锁”对象之后,”同步锁“对象就会记录这个线程的ID,这样其他线程就只能等待了,除非这个线程”释放“了锁对象,其他线程才能重新获得/占用”同步锁“对象。
同步锁对象可以是任意类型,但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。
对于同步代码块来说,同步锁对象是由程序员手动指定的(很多时候也是指定为this或类名.class),但是对于同步方法来说,同步锁对象只能是默认的:
-
静态方法:当前类的Class对象(类名.class)
-
非静态方法:this
同步操作的思考顺序
1、如何找问题,即代码是否存在线程安全?(非常重要) (1)明确哪些代码是多线程运行的代码 (2)明确多个线程是否有共享数据 (3)明确多线程运行代码中是否有多条语句操作共享数据
2、如何解决呢?(非常重要) 对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。 即所有操作共享数据的这些语句都要放在同步范围中
3、切记:
范围太小:不能解决安全问题
范围太大:因为一旦某个线程抢到锁,其他线程就只能等待,所以范围太大,效率会降低,不能合理利用CPU资源。
5.死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁。
一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
诱发死锁的原因:
-
互斥条件
-
占用且等待
-
不可抢夺(或不可抢占)
-
循环等待
以上4个条件,同时出现就会触发死锁。
解决死锁:
死锁一旦出现,基本很难人为干预,只能尽量规避。可以考虑打破上面的诱发条件。
针对条件1:互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。
针对条件2:可以考虑一次性申请所有所需的资源,这样就不存在等待的问题。
针对条件3:占用部分资源的线程在进一步申请其他资源时,如果申请不到,就主动释放掉已经占用的资源。
针对条件4:可以将资源改为线性顺序。申请资源时,先申请序号较小的,这样避免循环等待问题。
JDK5.0的新特性 Lock锁
-
JDK5.0的新增功能,保证线程的安全。与采用synchronized相比,Lock可提供多种锁方案,更灵活、更强大。Lock通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
-
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
-
在实现线程安全的控制中,比较常用的是
ReentrantLock
,可以显式加锁、释放锁。-
ReentrantLock类实现了 Lock 接口,它拥有与 synchronized 相同的并发性和内存语义,但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外,它还提供了在激烈争用情况下更佳的性能。
-
-
Lock锁也称同步锁,加锁与释放锁方法,如下:
-
public void lock() :加同步锁。
-
public void unlock() :释放同步锁。
-
synchronized与Lock的对比
-
Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出了作用域、遇到异常等自动解锁
-
Lock只有代码块锁,synchronized有代码块锁和方法锁
-
使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类),更体现面向对象。
-
(了解)Lock锁可以对读不加锁,对写加锁,synchronized不可以
-
(了解)Lock锁可以有多种获取锁的方式,可以从sleep的线程中抢到锁,synchronized不可以
说明:开发建议中处理线程安全问题优先使用顺序为:
• Lock ----> 同步代码块 ----> 同步方法
6.线程的通信
当我们需要多个线程
来共同完成一件任务,并且我们希望他们有规律的执行
,那么多线程之间需要一些通信机制,可以协调它们的工作,以此实现多线程共同操作一份数据。
比如:线程A用来生产包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,此时B线程必须等到A线程完成后才能执行,那么线程A与线程B之间就需要线程通信,即—— 等待唤醒机制。
这是多个线程间的一种协作机制
。谈到线程我们经常想到的是线程间的竞争(race)
,比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。
在一个线程满足某个条件时,就进入等待状态(wait() / wait(time)
), 等待其他线程执行完他们的指定代码过后再将其唤醒(notify()
);或可以指定wait的时间,等时间到了自动唤醒;在有多个线程进行等待时,如果需要,可以使用 notifyAll()
来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。
-
wait:线程不再活动,不再参与调度,进入
wait set
中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作
,也即“通知(notify)
”或者等待时间到,在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue
)中 -
notify:则选取所通知对象的 wait set 中的一个线程释放;
-
notifyAll:则释放所通知对象的 wait set 上的全部线程。
注意:
被通知的线程被唤醒后也不一定能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以它需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下:
-
如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE(可运行) 状态;
-
否则,线程就从 WAITING 状态又变成 BLOCKED(等待锁) 状态
调用wait和notify需注意的细节
-
wait方法与notify方法必须要由
同一个锁对象调用
。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。 -
wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
-
wait方法与notify方法必须要在
同步代码块
或者是同步函数
中使用。因为:必须要通过锁对象
调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常。
面试题L区分sleep()和wait()
相同点:一旦执行,都会使得当前线程结束执行状态,进入阻塞状态。
不同点:
① 定义方法所属的类:sleep():Thread中定义。 wait():Object中定义
② 使用范围的不同:sleep()可以在任何需要使用的位置被调用; wait():必须使用在同步代码块或同步方法中
③ 都在同步结构中使用的时候,是否释放同步监视器的操作不同:sleep():不会释放同步监视器 ;wait():会释放同步监视器
④ 结束等待的方式不同:sleep():指定时间一到就结束阻塞。 wait():可以指定时间也可以无限等待直到notify或notifyAll。
7.JDK5.0新增线程创建方式
新增方式一:实现Callable接口
-
与使用Runnable相比, Callable功能更强大些
-
相比run()方法,可以有返回值
-
方法可以抛出异常
-
支持泛型的返回值(需要借助FutureTask类,获取返回结果)
-
-
Future接口(了解)
-
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
-
FutureTask是Futrue接口的唯一的实现类
-
FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值
-
-
缺点:在获取分线程执行结果的时候,当前线程(或是主线程)受阻塞,效率较低。
新增方式二:使用线程池
现有问题:
如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。
那么有没有一种办法使得线程可以复用,即执行完一个任务,并不被销毁,而是可以继续执行其他的任务?
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
-
提高响应速度(减少了创建新线程的时间)
-
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
-
便于线程管理
-
corePoolSize:核心池的大小
-
maximumPoolSize:最大线程数
-
keepAliveTime:线程没有任务时最多保持多长时间后会终止
-