线程的生命周期和常见方法

一、线程的生命周期

线程声明周期：

线程开始 –》线程消亡

线程经历哪些阶段：

二、线程常见方法

（1）start() : 启动当前线程，表面上调用start方法，实际在调用线程里面的run方法

（2）run() : 线程类继承 Thread类或者实现Runnable接口的时候，都要重新实现这个run方法，run方法里面是线程要执行的内容

（3）currentThread :Thread类中一个静态方法：获取当前正在执行的线程

（4）setName 设置线程名字

（5）getName 读取线程名字

1、设置优先级

【1】同优先级别的线程，采取的策略就是先到先服务，使用时间片策略

【2】如果优先级别高，被CPU调度的概率就高

【3】级别：1-10 默认的级别为5

【4】代码：

package com.lanson.test06;

/**
 * @author : Lansonli
 */
public class TestThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

class TestThread02 extends Thread{
    @Override
    public void run() {
        for (int i = 20; i <= 30 ; i++) {
            System.out.println(i);
        }
    }
}

class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建两个子线程，让这两个子线程争抢资源：
        TestThread01 t1 = new TestThread01();
        t1.setPriority(10);//优先级别高
        t1.start();

        TestThread02 t2 = new TestThread02();
        t2.setPriority(1);//优先级别低
        t2.start();
    }
}

2、join

join方法：当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。

注意：必须先start，再join才有效。

package com.lanson.test07;

/**
 * @author : Lansonli
 */
public class TestThread extends Thread {
    public TestThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10 ; i++) {
            System.out.println(this.getName()+"----"+i);
        }
    }
}

class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("main-----"+i);
            if(i == 6){
                //创建子线程：
                TestThread tt = new TestThread("子线程");
                tt.start();
                tt.join();//“半路杀出个程咬金”
            }

        }
    }
}

3、sleep

sleep : 人为的制造阻塞事件

public class Test01 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("00000000000000");
    }
}

案例：完成秒表功能

package com.lanson.test08;

import javafx.scene.input.DataFormat;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author : Lansonli
 */
public class Test02 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //2.定义一个时间格式：
        DateFormat df = new SimpleDateFormat("HH:mm:ss");
        while(true){
            //1.获取当前时间：
            Date d = new Date();
            //3.按照上面定义的格式将Date类型转为指定格式的字符串：
            System.out.println(df.format(d));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4、setDaemon

【1】设置伴随线程

将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了

案例：皇上 –》驾崩 –》妃子陪葬

package com.lanson.test09;

/**
 * @author : Lansonli
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 1000 ; i++) {
            System.out.println("子线程----"+i);
        }
    }
}
class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建并启动子线程：
        TestThread tt = new TestThread();
        tt.setDaemon(true);//设置伴随线程  注意：先设置，再启动
        tt.start();

        //主线程中还要输出1-10的数字：
        for (int i = 1; i <= 10 ; i++) {
            System.out.println("main---"+i);
        }
    }
}

结果：

5、stop

package com.lanson.test09;

/**
 * @author : Lansonli
 */
public class Demo {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        for (int i = 1; i <= 100 ; i++) {
            if(i == 6){
                Thread.currentThread().stop();//过期方法，不建议使用
            }
            System.out.println(i);
        }
    }
}

顺便聊一下大数据必学Java基础（七十七）：线程的生命周期和常见方法

​线程的生命周期和常见方法