标签：width content ++ view stop isa 就会 raw ram
一，线程的生命周期
新生状态
用new关键字建立一个线程后，该线程对象就处于新生状态。
处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。
就绪状态
处于就绪状态线程具备了运行条件，但还没分配到CPU，处于线程就绪队列，等待系统为其分配CPU。
当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU调度”。
运行状态
在运行状态的线程执行自己的run方法中代码,直到等待某资源而阻塞或完成任何而死亡。
如果在给定的时间片内没有执行结束，就会被系统给换下来回到等待执行状态。
阻塞状态
处于运行状态的线程在某些情况下，如执行了sleep(睡眠)方法，或等待I/O设备等资源，将让出CPU并暂时停止自己运行，进入阻塞状态。
在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续执行。
死亡状态
死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有三个，一个是正常运行
的线程完成了它的全部工作；另一个是线程被强制性地终止，如通过stop方法来终止一个
线程【不推荐使用，可以用interrupt方法来终止】；三是线程抛出未捕获的异常
二，线程常用方法
（1）线程优先级
public static void main(String[] args) { // 线程优先级 System.out.println(Thread.MAX_PRIORITY); System.out.println(Thread.MIN_PRIORITY); System.out.println(Thread.NORM_PRIORITY); //设置线程优先级 (设置优先级表示被cpu调度的几率大，但不代表一定先运行) Student stu=new Student(); stu.setPriority(Thread.MAX_PRIORITY); stu.start(); }
（2）isAlive
public static void main(String[] args) { //isAlive判断线程是否处于活动状态 Student stu=new Student(); System.out.println(stu.isAlive()); stu.start(); System.out.println(stu.isAlive()); }
//线程调用start之后就处于活动状态
（3）join
调用该方法的线程强制执行，其它线程处于阻塞状态，该线程执行完毕后，其它线程再执行
join称为线程的强制执行，有可能被外界中断产生InterruptedException 中断异常
public static void main(String[] args) throws InterruptedException { Student stu=new Student(); stu.start(); for(int i=0;i<5;i++){ if(i==2){ stu.join();//main在抢占到i==2时就处于阻塞转态，让stu执行完再继续回到就绪状态 } System.out.println(Thread.currentThread().getName()+i); } }
（4）sleep
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态
public static void main(String[] args) throws InterruptedException { Student stu=new Student(); stu.start(); Thread mainThread=Thread.currentThread(); System.out.println(mainThread.getName()+"即将进入休眠"); Thread.sleep(3000); //终止线程 stu.interrupt(); }
（5）yield
当前线程给cpu调度器一个暗示，暗示其想礼让一次其拥有的cpu，CPU调度者也可以忽视这次暗示。此时当前线程进入就绪状态
public static void main(String[] args) throws InterruptedException { Student stu1=new Student(); stu1.start(); Thread main=Thread.currentThread(); for (int i= 0; i< 5; i++) { if(i==2){ Thread.yield(); //礼让一次，重新进入就绪 } System.out.println(Thread.currentThread().getName()+i); } }
三，线程安全问题（线程同步）
线程在执行过程中，通过cpu的调度，执行轨迹不确定，对共享资源的访问很容易造成数据的错误。我们称这个错乱称为线程安全问题
同步概念：
原子性操作:一个操作要么一次性做完，要么根本不开始，不存在中间状态。
同步就是让操作保持原子性！java提供两种方式实现同步
举例：卖票
public class Ticket implements Runnable { private int count=5; @Override public void run() { for (int i = 0; i < 5; i++) { if(count>0){ count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } }
public static void main(String[] args) throws InterruptedException { Ticket ticket=new Ticket(); Thread t1=new Thread(ticket,"a"); Thread t2=new Thread(ticket,"b"); Thread t3=new Thread(ticket,"c"); t1.start(); t2.start(); t3.start(); }
随机运行的其中一种结果是：
可以看出运行轨迹是混乱的。
解决方案：
（1）代码块同步
把所有的同步操作放到同步代码块中
synchronized (mutex) { // .. . }
mutex 称为互斥锁/同步锁。对共享资源进行加锁实现同步。一般用共享资源作为同步锁，也称同步监视器
具体答案：
public class Ticket implements Runnable { private int count=5; @Override public void run() { for (int i = 0; i < 5; i++) { synchronized (this) { if(count>0){ count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } } } }
（2）同步方法
如果同步代码(原子性)很多，可以考虑使用同步方法。
把普通方法用 synchronized 修饰，同步方法的同步监视器是this
具体代码：
public class Ticket implements Runnable { private int count=5; @Override public void run() { for (int i = 0; i < 5; i++) { this.saleTicket(); } } private synchronized void saleTicket(){ if(count>0){ count--; System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩" + count + "张票"); } } }
理解：就是把synchronized (this) {}里面的同步操作单拎出来放在synchronized 修饰的方法里面，然后再调用
四，死锁
线程t1，拥有A资源，再次申请B资源，线程t2,拥有B资源，再申请A资源。
t1因为没有申请到B资源而进入阻塞；t2因为没有申请到A资源进入阻塞。
此时两个线程都处于阻塞状态而不能正常结束，而此时cpu空转，这种情况称为死锁
帮助理解--->
甲：帮我带饭我再给你钱
乙：先给我钱我再帮你带饭。。。。一直僵持无法进入下一环节
标签：width content ++ view stop isa 就会 raw ram
原文地址：https://www.cnblogs.com/zhangxiong-tianxiadiyi/p/10840926.html
