多线程-Thread类的常用方法和生命周期
Thread类的常用结构
构造器
- public Thread():分配一个新的线程对象。
- public Thread(String name):分配一个指定名字的新的线程对象。
- public Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接口中的run()方法。
- public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
常用方法系列1
- public void run():此线程要执行的任务在此处定义代码。
- public void start():导致此线程开始执行；Java虚拟机调用此线程的run方法。
- public String getName():获取当前线程名称。
- public void setName():设置该线程名称。
- public static Thread currentThread():返回对当前正在执行的线程对象的引用。在Thread子类中就是this，通常用于主线程和Runnable实现类。
- public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
- public static void yield(): yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。
常用方法系列2
-
public final boolean isAlive(): 测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
-
void join(): 等待该线程终止。
void join(long millis): 等待该线程终止的时间最长为millis毫秒。如果millis时间到，将不再等待。
void join(long millis,int nanos): 等待该线程终止的时间最长为millis毫秒 + nanos 纳秒。
-
public final void stop():
已过时，不建议使用。强行结束一个线程的执行，直接进入死亡状态。run()即刻停止，可能会导致一些请理性的工作得不到完成，如文件，数据库等的关闭。同时，会立即释放该线程所持有的所有的锁，导致数据得不到同步的处理，出现数据不一致的问题。 -
void suspend() / void resume(): 这两个操作就好比播放器的暂停和恢复。二者必须成对出现，否则非常容易发生死锁。suspend()调用会导致线程暂停，但不会释放任何锁资源，导致其他线程都无法访问被它占用的锁，直到调用resume()。
已过时，不建议使用。
常用的方法系列3
每个线程都有一定的优先级，同优先级线程组成先进先出队列（先到先服务），使用分时调度策略。优先级高的线程采用抢占式策略，获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。
- Thread类的三个优先级常量：
- MAX_PRIORITY(10):最高优先级
- MIN_PRIORITY(1): 最低优先级
- NORM_PRIORITY（5）：普通优先级，默认情况下main线程具有普通优先级。
- public final int getPriority(): 返回线程优先级
- public final void setPriority(int newPriority): 改变线程的优先级，范围在[1——10]之间。
练习：获取main线程对象的名称和优先级。
声明一个匿名内部类继承Thread类，重写run方法，在run方法中获取线程名称和优先级。设置该线程优先级为最高优先级并启动该线程。
一、线程的常用结构
1. 线程中的构造器
- public Thread():分配一个新的线程对象。
- public Thread(String name):分配一个指定名字的新的线程对象。
- public Thread(Runnable target):指定创建线程的目标对象，它实现了Runnable接口中的run()方法。
- public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
2.线程中的常用方法：
> start(): （1）启动线程 （2）调用线程的run()
> run(): 将线程要执行的操作，声明在run()中。
> currentThread(): 获取当前执行代码对应的线程。
> getName(): 获取线程名
> setName(): 设置线程名
> sleep(long millis): 静态方法，调用时，可以使得当前线程睡眠指定的毫秒数
> yield(): 静态方法，一旦执行此方法，就释放CPU的执行权
> join(): 在线程a中通过线程b调用join()，意味着线程a进入阻塞状态，直到线程b执行结束，线程a才结束阻塞状态，继续执行
> isAlive(): 判断当前线程是否还存活
过时方法：
> stop(): 强行结束一个线程的执行，直接进入死亡状态。不建议使用
> void suspend() / void resume() : 可能造成死锁，所以也不建议使用
3.线程的优先级：
getPriority(): 获取线程的优先级
setPriority(): 设置线程的优先级。范围是[1,10]
Thread类内部声明的三个常量：
- MAX_PRIORITY(10):最高优先级
- MIN_PRIORITY(1): 最低优先级
- NORM_PRIORITY（5）：普通优先级，默认情况下main线程具有普通优先级。
二、线程的生命周期
常用方法练习：
package thread.demo02;
public class EvenNumberTest {
public static void main(String[] args) {
//测试1
PrintNumber t1 = new PrintNumber("线程1：偶数");
t1.setName("线程1（修改）：偶数");//修改上面的线程名"线程1：偶数"为"线程1（修改）：偶数"
t1.setPriority(Thread.MAX_PRIORITY);//注意不是哪个优先级高就先运行完哪个线程，是CPU几率更高优先来调用优先级高的线程。
// 打印出来发现还是主线程第一个运行，因为现在都是多核CPU，这是概率问题。
t1.start();
//测试setName()
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName() + " 优先级为:" +
Thread.currentThread().getPriority() + ": " + i);
}
// if (i == 20){
// try {
// t1.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
}
//测试isAlive()
// System.out.println("线程1（修改）：偶数 是否存活？" + t1.isAlive());
//测试2
PrintNumber1 p = new PrintNumber1();
Thread t2 = new Thread(p,"线程2：奇数");
t2.start();
}
}
//测试1:-public Thread(String name):分配一个指定名字的新的线程对象。
class PrintNumber extends Thread{
//无参构造
public PrintNumber(){
}
//分配一个指定名字的新的线程对象。
public PrintNumber(String name){
super(name);
}
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//测试sleep()
// try {
// Thread.sleep(1000);//设置了1000毫秒也就是一秒，对应的这个线程1一秒钟执行一下，直到结束
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName() + " 优先级为:" +
Thread.currentThread().getPriority() + ": " + i);
}
//测试yield()
// if (i % 20 == 0){
// Thread.yield();
// }
}
}
}
//测试2:- public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
class PrintNumber1 implements Runnable{
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0){
System.out.println(Thread.currentThread().getName() + " 优先级为: " +
Thread.currentThread().getPriority() + " " + i);
}
}
}
}
多线程的生命周期
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）执行。
4.阻塞
当在运行过程中的线程遇到如下情况时，会让出CPU并临时中止自己的执行，进入阻塞状态：
- 线程调用了sleep()方法，主动放弃所占用的CPU资源；
- 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
- 线程执行过程中，同步监视器调用了wait()，让它等待某个通知(notify);
- 线程执行过程中，同步监视器调用了wait(time);
- 线程执行过程中，遇到了其他线程对象的加塞（join）;
- 线程被调用suspend方法被挂起(已过时，因为容易发生死锁);
当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入阻塞状态，等待线程调度器再次调度它：
- 线程的sleep()时间到；
- 线程成功获得了同步监视器；
- 线程等到了通知(notify);
- 线程wait的时间到了
- 加塞的线程结束了；
- 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；
5.死亡
线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：
- run()方法执行完成，线程正常结束
- 线程执行过程中抛出了一个未捕获的异常(Exception)或错误(Error)
- 直接调用该线程的stop()来结束该线程(已过时)
JDK1.5及之后：6种状态
在java.lang.Thread.State的枚举类中这样定义：
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
下图中在JAVA基础阶段暂时了解一下，不去看里面具体方法，以后在JUC里面再看
