Thread类及常见方法

目录

前言：

1.Thread类

2.Thread类的常见构造方法

3.Thread类的常见属性

4.启动一个线程-start()

5.等待一个线程-join()

6.休眠一个线程-sleep()

7.获取当前的线程引用

---

前言：

 在学会创建Thread类线程对象后，下来就要学会使用Thread对象进行具体的线程操作。

 在Thread类中有很多方法，本节对这些方法进行介绍。

序列：多线程 - 003

---

1.Thread类

定义：Thread 类是JVM用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对像与之关联。

对于每个执行流，需要有一个对象来描述，类似下图所示，而Thread类的对象就是用来描述一个线程执行流的，JVM会将这些 Thread 对象组织起来，用于线程调度，线程管理。

2.Thread类的常见构造方法

Thread类的常见构造方法：

方法：	说明：
Thread ( )	创建线程对象
Thread(Runnable  target)	使用实现Runnable接口的类的对象创建线程对象
Thread(String  "name")	创建线程对象并命名
Thread(Runnable  target , String  "name")	使用实现Runnable接口的类的对象创建线程，并命名

Example：

• Thread t1 = new Thread();
• Thread t2 = new Thread(new MyRunnable());
• Thread t3 = new Thread("线程名称");
• Thread t4 = new Thread(new MyRunnable(), "线程名称");

3.Thread类的常见属性

 Thread类的常见属性如下：

属性：	获取方法：
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中段	isInterrupted()

• ID 是线程的唯一标识，不同线程不会重复；
• 名称是各种调试工具用到；
• 状态表示线程当前所处的一个情况；
• 优先级高的线程理论上来说更容易被调度到；
• 一个java进程中，前台线程没有结束，则整个进程不会结束；
• 一个java进程中，后台线程不结束，不影响整个进程的结束；
• JVM会在一个进程的所有非后台线程结束后，才会结束运行；
• 是否存活，即简单的理解，run 方法是否运行结束了。

Example：

public class ThreadAttribute {//线程属性类
    public static void main(String[] args) {
        Thread thread = new Thread(()->{//lambda表达式创建线程
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "线程正在运行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println(Thread.currentThread().getName() + "线程运行结束...");
        });
        thread.start();//启动线程thread
        System.out.println("线程ID："+Thread.currentThread().getId());
        System.out.println("线程name："+Thread.currentThread().getName());
        System.out.println("线程状态："+Thread.currentThread().getState());
        System.out.println("线程优先级："+Thread.currentThread().getPriority());
        System.out.println("线程后台线程："+Thread.currentThread().isDaemon());
        System.out.println("线程存活："+Thread.currentThread().isAlive());
        System.out.println("线程中断："+Thread.currentThread().isInterrupted());
    }
}

4.启动一个线程-start()

重写run()方法是提供给线程要做的事，并不会直接运行调用，而是会在start()创建并开始运行线程之后，自动被调用。

调用start()方法，才是真正的在操作系统中创建出一个线程并开始运行。

public class Deom {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{//采用lambda表达式创建线程对象
            System.out.println("这是一个线程A...");
        });
        thread.start();//调用start()方法创建出thread线程并运行
        System.out.println("这是main线程...");
    }
}

5.等待一个线程-join()

有时我们需要等待一个线程完成它的工作后，才能进行下一步工作。让一个线程去等待另一个线程执行结束，再继续执行；本质上是控制线程结束的顺序。

让main线程等待thread01和thread02线程运行结束之后再打印n和m的值。

代码如下：

public class aaa {
    public static int n = 0;
    public static int m = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread01 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                n++;
            }
        });
        Thread thread02 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                m++;
            }
        });
        thread01.start();//启动线程thread01
        thread02.start();//启动线程thread02
        thread01.join();//main线程线程等待thread01
        thread02.join();//main线程线程等待thread02
        System.out.println("n的值为：" + n);
        System.out.println("m的值为：" + m);
    }
}

等待效果：main线程调用join()方法，执行thread.join()语句，此时就是main线程阻塞等待thread线程先结束，直到thread线程运行结束。

• A线程中调用B.join()方法，则A线程阻塞等待B线程执行完毕后，A才运行；
• 如果B线程已经执行结束，此时A中调用B.join()方法，会直接返回，A线程不会涉及到阻塞。

//在main方法中
...  
     thread.start();
     thread.join(); //main线程阻塞，thread线程运行
...

join()默认是“死等”，一般来说等待的操作都是带一个“超时时间”。

方法	说明
public void join()	等待线程结束，“死等”
public void join(long millis)	等待线程结束，最对等millis毫秒
public void join(long millis,int nanos)	等待线程结束，最多等millis毫秒，nanos微秒

6.休眠一个线程-sleep()

因为线程的调度是不可控的，所以可以使用sleep()方法进行相对的控制，对线程进行休眠。

sleep()方法是Thread类的静态方法，所以可以使用类名可以进行直接调用，如：Thread.sleep()直接调用。

方法	说明
public static void sleep(long millis) throws InterruptedException	休眠当前线程millis毫秒
public static void sleep(long millis,int nanos) throws InterruptedException	休眠当前线程millis毫秒,nanos纳秒

代码如下：

public class aaa {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(3000);//sleep()休眠当前线程3秒钟
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("这是thread线程...");
        });
        thread.start();//启动线程thread
    }
}

7.获取当前的线程引用

在线程中使用，可以直接引用出当前线程。currentThread()方法也是Thread类的静态方法。

方法	说明
public static Thread currentThread();	返回当前的线程的引用

代码如下：

public class aaa {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            System.out.println(Thread.currentThread());//打印thread线程
        });
        thread.start();//启动线程thread
        System.out.println(Thread.currentThread());//打印main线程
    }
}

---

以上便是Thread类的基本属性与方法。