在线程的生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)5 种状态。尤其是当线程启动以后,它不可能一直"霸占"着 CPU 独自运行,所以 CPU 需要在多条线程之间切换,于是线程状态也会多次在运行、阻塞之间切换。
- 新建(NEW):当程序使用 new 关键字创建了一个线程对象之后,该线程就处于新建状态,此时仅由 JVM 为其分配内存,并初始化其成员变量的值。
- 就绪(RUNNABLE ):当线程对象调用了 start() 方法之后,该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器,等待调度运行。
- 运行(RUNNING ):如果处于就绪状态的线程获得了 CPU,开始执行 run() 方法的线程执行体,则该线程处于运行状态。
- 阻塞(BLOCKED):阻塞状态是指线程因为某种原因放弃了 cpu 使用权,也即让出了 cpu timeslice,暂时停止运行。直到线程进入可运行(runnable)状态,才有机会再次获得 cpu timeslice 转到运行(running)状态。阻塞的情况分三种:
a、等待阻塞 ( o.wait-> 等待对列 ) :运行 (running) 的线程执行 o.wait() 方法,JVM 会把该线程放入等待队列 (waitting queue) 中。
b、同步阻塞 (lock-> 锁池 ):运行 (running)的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则 JVM 会把该线程放入锁池 (lock pool) 中。
c、其他阻塞(sleep/join):运行(running)的线程执x行Thread.sleep(long ms)或 t.join()方法,或者发出了I/O 请求时,JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入可运行(runnable)状态。
- 线程死亡(DEAD):线程会以下面三种方式结束,结束后就是死亡状态。
二、线程的状态(NEW, RUNNABLE, BLOCKED ,WAITING, TIME_WAITINTG,TERMINATED)正常结束: run()或 call()方法执行完成,线程正常结束。
异常结束:线程抛出一个未捕获的 Exception 或 Error。
调用 stop:直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁,不推荐使用。
- NEW(新建)线程刚被创建,但未被启动。也就是没有调用start方法。
- Runnable(可运行)线程可以在java的虚拟机中运行的状态(包含两种情况Ready和Running),可能正在运行自己的代码,也可能没有,这取决于cpu是否扫描到这一个线程。
- Blocked(锁阻塞)当一个线程试图获取一个对象锁,而这对象锁被其他线程持有,则该线程进入Blocked状态;当该线程持有锁时,该线程将变成Runnable状态。
- Waiting(无限等待)一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个状态后不能自动唤醒,必须等待另一个线程调用notify方法或者notifyAll方法时才能够被唤醒。
- Time Waiting(计时等待)同Waiting状态,有几个方法超时参数,调用他们将进入TimeWaiting状态。这一状态将一直保持到超时期满或者就收到唤醒通知。带有超时参数的常用方法有Thread.sleep(毫秒值)方法和Object.wait()方法。(Object必须是锁对象66)通俗理解:线程在遇到sleep方法和wait方法时就会进入Time Waiting状态。
- Teminated(死亡状态)因为run方法正常的退出而死亡,或者因为遇到异常而死亡。
三、创建线程的方式:Java的Thread类中枚举了一下6个状态:
- NEW A thread that has not yet started is in this state.
- RUNNABLE A thread executing in the Java virtual machine is in this state.
- BLOCKED A thread that is blocked waiting for a monitor lock is in this state.
- WAITING A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
- TIMED_WAITING A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
- TERMINATED A thread that has exited is in this state.
- 继承Thread类
- 实现Runnable接口
- FutureTask配合Callable接口(这种方式需要配合线程池使用)
四、线程基本方法FutureTask能够接收Callable类型的参数,用来处理有返回的结果
FutureTaskfutureTask = new FutureTask<>(()->{ return 1; }); new Thread(futureTask).start(); System.out.println(futureTask.get());
1、 sleep() 线程睡眠一段时间,但是不会释放资源
2、yield() 线程退出cpu使用,进入到就绪状态,其他线程可以使用cpu
3、join() 线程等待另一个线程运行完,join(long n)等待线程结束,最多等待n毫秒
4、interrupt()方法
1 wait和notify
- sleep() 和 wait() 有什么区别?
两者都可以暂停线程的执行
1)类的不同:sleep() 是 Thread线程类的静态方法,wait() 是 Object类的方法。
2)是否释放锁:sleep() 不释放锁;wait() 释放锁。
3)用途不同:Wait 通常被用于线程间交互/通信,sleep 通常被用于暂停执行。
4)用法不同:wait() 方法被调用后,线程不会自动苏醒,需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后,线程会自动苏醒。或者可以使用wait(long timeout)超时后线程会自动苏醒。
- 线程等待wait
调用该方法的线程进入 WAITING 状态,只有等待另外线程的通知或被中断才会返回,需要注意的是调用 wait()方法后,会释放对象的锁。因此,wait 方法一般用在同步方法或同步代码块中。 - 线程唤醒(notify)
Object 类中的 notify() 方法,唤醒在此对象监视器上等待的单个线程,如果所有线程都在此对象上等待,则会选择唤醒其中一个线程,选择是任意的,并在对实现做出决定时发生,线程通过调用其中一个 wait() 方法,在对象的监视器上等待,直到当前的线程放弃此对象上的锁定,才能继续执行被唤醒的线程,被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。类似的方法还有 notifyAll() ,唤醒再次监视器上等待的所有线程。
join() 方法,等待其他线程终止,在当前线程中调用一个线程的 join() 方法,则当前线程转为阻塞状态,回到另一个线程结束,当前线程再由阻塞状态变为就绪状态,等待 cpu 的宠幸。
很多情况下,主线程生成并启动了子线程,需要用到子线程返回的结果,也就是需要主线程需要在子线程结束后再结束,这时候就要用到 join() 方法。
System.out.println(Thread.currentThread().getName() + "线程运行开始!");
Thread6 thread1 = new Thread6();
thread1.setName("线程 B");
thread1.join();
System.out.println("这时 thread1 执行完毕之后才能执行主线程")
五、终止线程的几种方式
1 正常运行结束
2 使用退出标志退出线程
3 Interrupt方法结束线程
4 stop 方法终止线程(线程不安全)
- 缺点:会出现内存泄漏、上下文切换、线程安全、死锁等问题。
1 可见性,一个线程对共享变量的修改,另一个线程能够立刻看到。(synchronized,volatile)
2 有序性,程序执行的顺序按照代码的先后顺序执行。(处理器可能会对指令进行重排序)
3 原子性,原子,即一个不可再被分割的颗粒。原子性指的是一个或多个操作要么全部执行成功要么全部执行失败。
线程上下文切换(Thread Context Switch)
当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态,以便下次再切换回这个任务时,可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。
1 线程的CPU时间片用完了
2 垃圾回收
3 有更高优先级的线程需要执行
4 线程自己调用了sleep、yield、wait、join、synchronized、lock等方法
出现线程安全问题的原因:
1、线程切换带来的原子性问题
2、缓存导致的可见性问题
3、编译优化带来的有序性问题解决办法:
JDK Atomic开头的原子类、synchronized、LOCK,可以解决原子性问题
synchronized、volatile、LOCK,可以解决可见性问题
Happens-Before 规则可以解决有序性问题
死锁
死锁是指两个或两个以上的进程(线程)在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程(线程)称为死锁进程(线程)。
1 形成死锁的四个必要条件是什么
互斥条件:线程(进程)对于所分配到的资源具有排它性,即一个资源只能被一个线程(进程)占用,直到被该线程(进程)释放
请求与保持条件:一个线程(进程)因请求被占用资源而发生阻塞时,对已获得的资源保持不放。
不剥夺条件:线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺,只有自己使用完毕后才释放资源。
循环等待条件:当发生死锁时,所等待的线程(进程)必定会形成一个环路(类似于死循环),造成永久阻塞。
二、 synchronized关键字2 如何避免线程死锁
1)破坏请求与保持条件: 一次性申请所有的资源。
2)破坏不剥夺条件: 占用部分资源的线程进一步申请其他资源时,如果申请不到,可以主动释放它占有的资源。
3)破坏循环等待条件:靠按序申请资源来预防。按某一顺序申请资源,释放资源则反序释放。破坏循环等待条件。
synchronized(对象,该对象可以java普通对象或者类对象)
synchronized实际是使用对象锁保证了线程安全
synchronized的使用
1 作用于方法时,锁住的是对象的实例(this);
2.当作用于静态方法时,锁住的是Class实例,又因为Class的相关数据存储在永久带PermGen(jdk1.8 则是 metaspace),永久带是全局共享的,因此静态方法锁相当于类的一个全局锁,会锁所有调用该方法的线程;
3 synchronized 作用于一个对象实例时,锁住的是所有以该对象为锁的代码块。它有多个队列,当多个线程一起访问某个对象监视器的时候,对象监视器会将这些线程存储在不同的容器中。
Synchronized 核心组件
- Wait Set:哪些调用 wait 方法被阻塞的线程被放置在这里;
- ContentionList:竞争队列,所有请求锁的线程首先被放在这个竞争队列中;
- Entry List:Contention List中那些有资格成为候选资源的线程被移动到 Entry List 中;
4)OnDeck:任意时刻,最多只有一个线程正在竞争锁资源,该线程被成为 OnDeck;- Owner:当前已经获取到所资源的线程被称为Owner;
- !Owner:当前释放锁的线程
补充Java对象头概念
以32位虚拟机为例
普通对象 Object Header(64位):MarkWord(32位)、Klass(32位)
MarkWord结构
Integer 8+4字节 对象头占了8个字节
int 4字节
synchronized锁升级
锁的状态总共有四种:无锁状态、偏向锁、轻量级锁和重量级锁。
- 偏向锁
Hotspot 的作者经过以往的研究发现大多数情况下锁不仅不存在多线程竞争,而且总是由同一线程多次获得。偏向锁的目的是在某个线程获得锁之后,消除这个线程锁重入(CAS)的开销,看起来让这个线程得到了偏护。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径,因为轻量级锁的获取及释放依赖多次 CAS 原子指令,而偏向锁只需要在置换ThreadID 的时候依赖一次 CAS 原子指令(由于一旦出现多线程竞争的情况就必须撤销偏向锁,所以偏向锁的撤销操作的性能损耗必须小于节省下来的 CAS 原子指令的性能消耗)。轻量级锁是为了在线程交替执行同步块时提高性能,而偏向锁则是在只有一个线程执行同步块时进一步提高性能。
一个对象创建时,默认开启偏向锁(Biased),而且偏向锁时延时的,不会在程序启动时立即生效,可以通过修改vm参数使其不延时。
- 轻量级锁
轻量级锁是相对于使用操作系统互斥量来实现的传统锁而言的。但是,首先需要强调一点的是,轻量级锁并不是用来代替重量级锁的,它的本意是在没有多线程竞争的前提下,减少传统的重量级锁使用产生的性能消耗。在解释轻量级锁的执行过程之前,先明白一点,轻量级锁所适应的场景是线程交替执行同步块的情况,如果存在同一时间访问同一锁的情况,就会导致轻量级锁膨胀为重量级锁
锁升级
随着锁的竞争,锁可以从偏向锁升级到轻量级锁,再升级的重量级锁(但是锁的升级是单向的,也就是说只能从低到高升级,不会出现锁的降级)。
当线程1对对象A进行加锁,A对象的锁状态变成00,另一个线程2也来加锁,但是由于A对象已经被加锁,所以需要对A的MarkWord申请一个monitor,同时线程2记录到entryList等待。
轻量级锁使用场景
如果一个对象虽然有多线程访问,但多线程访问的时间是错开的(没有形成竞争的情况),就可以用轻量级锁来优化synchronized的性能
- 重量级锁
每个java对象都可以关联一个Monitor,如果使用synchronized给对象上锁(重量级锁)之后,该对象的markword中就被设置只想Monitor对象的指针。
每一个 Thread 的类都有一个 start 方法。 当调用 start 启动线程时 Java 虚拟机会调用该类的 run 方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我们可以继承重写Thread 类,在其 start 方法中添加不断循环调用传递过来的 Runnable 对象。 这就是线程池的实现原理。循环方法中不断获取 Runnable 是用 Queue 实现的,在获取下一个 Runnable 之前可以是阻塞的。
线程池的状态ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态,低 29 位表示线程数量,从数字上比较,TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING。
这些信息存储在一个原子变量 ctl 中,目的是将线程池状态与线程个数合二为一,这样就可以用一次 cas 原子操作
进行赋值
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime,TimeUnit unit, BlockingQueueworkQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit,workQueue,Executors.defaultThreadFactory(), defaultHandler); }
- corePoolSize:指定了线程池中的线程数量。
- maximumPoolSize:指定了线程池中的最大线程数量。
- keepAliveTime:当前线程池数量超过 corePoolSize 时,多余的空闲线程的存活时间,即多次时间内会被销毁。
- unit:keepAliveTime 的单位。
- workQueue:任务队列,被提交但尚未被执行的任务。
- threadFactory:线程工厂,用于创建线程,一般用默认的即可。
- handler:拒绝策略,当任务太多来不及处理,如何拒绝任务



