解析java线程中的常用方法

1 获取当前线程对象的引用

1.1 内容

public static Thread currentThread();

1.2 使用分析

它是一个静态方法,可以通过类名.调用

无需传入任何实参

返回值为Thread对象(线程对象)

通常和线程对象.getName方法配合使用,用来得到当前方法里面运行的是哪个线程

1.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<10){
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

ThreadTest类

package Work4;

public class ThreadTest {
    public static void main(String[] args) {
       //main线程的名字就是main,静态方法也可以通过类名.调用,本质还是类名.静态方法名
        System.out.println("main线程的名字为: "+Thread.currentThread().getName());
        Thread t=new Thread(new Cat());
        System.out.println("使用对象名.静态方法的结果为: "+t.currentThread().getName());
    }
}

1
2
3
4
5
6
7
8
9
10
11

1.4 示例代码运行截图

2 获取线程的名字

2.1 内容

public final String getName()

2.2 使用分析

被final修饰,意味着该方法不能被重写

无需传入任何实参

返回值为String类型,谁调用,返回谁的名字

2.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<10){
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        Thread t=new Thread(new Cat());
        //获取自定义的线程的名字,若没有修改,默认是按照Thread-序号的方式进行命名,序号从0开始
        System.out.println(t.getName());
    }
}

1
2
3
4
5
6
7
8
9

2.4 示例代码运行截图

3 设置线程的名字

3.1 内容

public final void String setName(String name)

3.2 使用分析

被final修饰,意味着该方法不能被重写

需要传入自定义的线程名字

返回值为void,谁调用,就是谁的名字被更改

3.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<10){
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        //创建一个线程,这个状态是NEW的状态
        Thread t=new Thread(new Cat());
        //自定义线程的名字
        t.setName("catA线程");
        System.out.println(t.getName());
    }
}

1
2
3
4
5
6
7
8
9
10
11

3.4 示例代码运行截图

4 获取线程的当前状态

4.1 内容

public Thread.State getState()

4.2 使用分析

无需传入实参

返回值类型为Thread.State

可以用来监视系统的状态

4.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<10){
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        Thread t=new Thread(new Cat());
        //创建后,线程的状态应该是NEW的状态
        System.out.println("创建但未运行时线程的状态为: "+t.getState());
        t.start();
        //启动start方法后,线程的状态应该是Runnale(可运行)状态
        System.out.println("启动start方法后,线程的状态为: "+t.getState());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

4.4 示例代码运行截图

5 使当前线程睡眠(进入TimedWaiting状态)

5.1 内容

public static void sleep(long millis)

5.2 使用分析

被static修饰,因此可以通过类名.sleep的方式调用

返回值类型为void

形参为long类型,实参传入整数类型即可,int类型的字面量也行,因为会发生自动类型转换

形参单位是毫秒,其中1秒=1000毫秒;

谁调用,谁睡眠,睡眠时间由传入的实参时间决定

5.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<10){
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        Thread t=new Thread(new Cat());
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main线程睡眠5s后再打印这句话!!!!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5.4 示例代码运行截图

6 当一个线程睡眠时间很长,我们想让它醒来

6.1 内容

public void interrupt()

6.2 使用分析

6.2.1 内容

返回值类型为void
形参无,因此无需传入实参
谁调用就终止谁的线程

6.2.2 实际使用

终止正在睡眠的线程(TimedWaiting状态),实际上就是返回线程开启睡眠的所在行,抛出一个异常,然后进入catch里面,catch里面写一些醒来后的逻辑.

6.2.3 使用场景

某个线程需要运行但是不急着运行,因为cpu的时间片等资源有限,我们就会先让该线程睡眠比较长的时间,然后当cpu不这么忙的时候,我们就把该线程唤醒它,让它去执行它里面对应的逻辑

6.3 示例代码

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        int count=0;
        try {
              Thread.sleep(1000*60*60*24);
        } catch (InterruptedException e) {
            System.out.println("唤醒线程: "+Thread.currentThread().getName());
            System.out.println("线程名"+Thread.currentThread().getName()+"的小猫咪正在喵喵喵"+(++count));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        Thread t=new Thread(new Cat());
        t.start();
        for (int i = 0; i <10; i++) {
            System.out.println("主线程在运行: "+Thread.currentThread().getName()+(i));
        }
        t.interrupt();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

6.4 示例代码运行截图

7 经典面试题

7.1 题目

阅读以下代码,思考t.sleep(1000)是让哪个线程睡眠5秒

Cat类

package Work4;
public class Cat implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程在运行");
    }
}

1
2
3
4
5
6
7
8

ThreadTest类

package Work4;
public class ThreadTest {
    public static void main(String[] args) {
        Thread t=new Thread(new Cat());
        t.start();
        try {
            t.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main线程执行结束");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.2 分析

对象名.静态方法名本质还是通过类名.静态方法名的方式去进行调用

而Thread.sleep(1000)的作用是让当前线程(在哪个方法里面就是哪个的线程)睡眠

因此t.sleep(1000)让main线程睡眠了1秒

因此会先执行完t对应的线程里面的逻辑,再执行main线程睡眠后面的逻辑

7.3 题目的运行结果