第十八章 18.3 线程的编号和名称

18.4 线程的编号和名称（熟悉）

方法声明 功能介绍

l**ong getId() **
**获取调用对象所表示线程的编号**
**String getName() **
**获取调用对象所表示线程的名称**
**void setName(String name) **
**设置**``**/**``**修改线程的名称为参数指定的数值**
**static Thread currentThread() **
**获取当前正在执行线程的引用**
**案例题目**
**自定义类继承**``**Thread**``**类并重写**``**run**``**方法，在**``**run**``**方法中先打印当前线程的编号和名称，然后将线程**
**的名称修改为**``**"zhangfei"**``**后再次打印编号和名称。**
**要求在**``**main**``**方法中也要打印主线程的编号和名称。**

案例题目

自定义类继承Thread类并重写run方法，在run方法中先打印当前线程的编号和名称，然后将线程的名称修改为”zhangfei”后再次打印编号和名称。
要求在main方法中也要打印主线程的编号和名称。
**

1.使用继承Thread类的方式获取线程的编号和名称

package com.lagou.task18;
public class ThreadIdNameTest extends Thread {
public ThreadIdNameTest(String name) {
super(name); // 表示调用父类的构造方法
}
@Override
public void run() {
System.out.println("子线程的编号是：" + getId() + "，名称是：" + getName()); // 14 Thread-0 guanyu
// 修改名称为"zhangfei"
setName("zhangfei");
System.out.println("修改后子线程的编号是：" + getId() + "，名称是：" + getName()); // 14 zhangfei
}
public static void main(String[] args) {
ThreadIdNameTest tint = new ThreadIdNameTest("guanyu");
tint.start();
// 获取当前正在执行线程的引用，当前正在执行的线程是主线程，也就是获取主线程的引用
//主线程的获取
**Thread t1 = Thread.currentThread();
System.out.println("主线程的编号是：" + t1.getId() + ", 名称是：" + t1.getName());
}
}**

2.使用接口的方式实现线程的编号和名称

**package **``**task18**``**;**``**public class **``**ThreadTwoTest **``**implements **``**Runnable{**
** Thread **``**t1 **``**= **``**new **``**Thread()**``**;**``** **``**@Override**``** **``**public void **``**run**``**() {**
** Thread t1 = Thread.**``**_currentThread_**``**()**``**;**``** **``**System.**``**_out_**``**.println(**``**"**``**子线程的编号是：**``** "**``**+t1.getId() +**``**"**``**，名称是：**``**"**``**+t1.getName())**``**;**``** **``**}**

** **``**public static void **``**main**``**(String[] args) {**
** ThreadTwoTest tw = **``**new **``**ThreadTwoTest()**``**;**``** **``**Thread t2 = **``**new **``**Thread(tw)**``**;**``** **``**t2.setName(**``**"**``**张飞**``**"**``**)**``**;**``** **``**t2.start()**``**;**``** **``**//**``**获取主线程**``** **``**Thread t1 = Thread.**``**_currentThread_**``**()**``**;**
** **``**System.**``**_out_**``**.println( **``**"**``**主线程的编号是：**``** "**``**+t1.getId() +**``**"**``**，名称是：**``**"**``**+t1.getName())**``**;**``** **``**}**
**}**
**

18.5 常用的方法（重点）

方法声明 功能介绍
static void yield()
当前线程让出处理器（离开``Running``状态），使当前线程进入Runnable 状态等待
static void sleep(times)
使当前线程从`` Running ``放弃处理器进入``Block``状态``, ``休眠``times``毫秒``, 再返回到``Runnable``如果其他线程打断当前线程的``Block(sleep), ``就会生
InterruptedException 异常
int getPriority()
获取线程的优先级
void setPriority(int newPriority)
修改线程的优先级。
优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些
void join()
等待该线程终止
void join(long millis)
等待参数指定的毫秒数
boolean isDaemon()
用于判断是否为守护线程
void setDaemon(boolean on)
用于设置线程为守护线程

Sleep方法的使用 。

package com.lagou.task18;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
public class ThreadSleepTest extends Thread {
// 声明一个布尔类型的变量作为循环是否执行的条件
**private boolean flag = true;
// 子类中重写的方法不能抛出更大的异常
@Override
public void run() {
// 每隔一秒获取一次系统时间并打印，模拟时钟的效果
while (flag) {
// 获取当前系统时间并调整格式打印
// LocalDateTime.now();
`****Date d1 = new Date();**<br />** SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);**<br />** System.out.println(sdf.format(d1));**<br />** // 睡眠1秒钟**<br />** ****try {**<br />** Thread.sleep(1000);**<br />** } catch (InterruptedException e) {**<br />** e.printStackTrace();**<br />** }**<br />** }**<br />** }**<br />** public static void main(String[] args) {**<br />** ThreadSleepTest tst = new ThreadSleepTest();**<br />** tst.start();**<br />** // 主线程等待5秒后结束子线程**<br />** System.out.println(“主线程开始等待…”);**<br />** ****try {**<br />** Thread.sleep(5000);**<br />** } catch (InterruptedException e) {**<br />** e.printStackTrace();**<br />** }**<br />** // 停止子线程 过时 不建议使用**<br />** //tst.stop();**<br />** **** tst.flag = false;**<br />** System.out.println(“主线程等待结束！”);**<br />** }**<br />**}`**

线程的优先级管理

**package com.lagou.task18;**
**public class ThreadPriorityTest extends Thread {**
** @Override**
** public void run() {**
** //System.out.println("子线程的优先级是：" + **``**getPriority()**``**); // 5 10 优先级越高的线程不一定先执行。**
** for (int i = 0; i < 20; i++) {**
** System.out.println("子线程中：i = " + i);**
** }**
** }**
** public static void main(String[] args) {**
** ThreadPriorityTest tpt = new ThreadPriorityTest();**
** // 设置子线程的优先级**
** **``** tpt.setPriority(Thread.MAX_PRIORITY);**
** tpt.start();**
** Thread t1 = Thread.currentThread();**
** //System.out.println("主线程的优先级是：" + **``**t1.getPriority()**``**); // 5 普通的优先级**
** for (int i = 0; i < 20; i++) {**
** System.out.println("--主线程中：i = " + i);**
** }**
** }**
**}**

线程的等待

**package com.lagou.task18;**
**public class ThreadJoinTest extends Thread {**
** @Override**
** public void run() {**
** // 模拟倒数10个数的效果**
** System.out.println("倒计时开始...");**
** for (int i = 10; i > 0; i--) {**
** System.out.println(i);**
** **``**try {**
** Thread.sleep(1000);**
** } catch (InterruptedException e) {**
** e.printStackTrace();**
** }**
** }**
** System.out.println("新年快乐！");**
** }**
** public static void main(String[] args) {**
** ThreadJoinTest tjt = new ThreadJoinTest();**
** tjt.start();**
** // 主线程开始等待**
** System.out.println("主线程开始等待...");**
** try {**
** // 表示当前正在执行的线程对象等待调用线程对象，也就是主线程等待子线程终止**
** //tjt.join();**
** **``** tjt.join(5000);**``** // 最多等待5秒**
** } catch (InterruptedException e) {**
** e.printStackTrace();**
** }**
** //System.out.println("终于等到你，还好没放弃！");**
** System.out.println("可惜不是你，陪我到最后！");**
** }**
**}**

守护线程

**package com.lagou.task18;**
**public class ThreadDaemonTest extends Thread {**
** @Override**
** public void run() {**
** //**``**System.out.println(isDaemon()?**``** "该线程是守护线程": "该线程不是守护线程"); // 默认不是守护线程**
** // 当子线程不是守护线程时，虽然主线程先结束了，但是子线程依然会继续执行，直到打印完毕所有数据为止**
** // 当子线程是守护线程时，当主线程结束后，则子线程随之结束**
** for (int i = 0; i < 50; i++) {**
** System.out.println("子线程中：i = " + i);**
** }**
** }**
** public static void main(String[] args) {**
** ThreadDaemonTest tdt = new ThreadDaemonTest();**
** // 必须在线程启动之前设置子线程为守护线程**
** **``**tdt.setDaemon(true);**
** tdt.start();**
** for (int i = 0; i < 20; i++) {**
** System.out.println("-------主线程中：i = " + i);**
** }**
** }**
**}**

案例题目

编程创建两个线程，线程一负责打印1 ~ 100之间的所有奇数，其中线程二负责打印1 ~ 100之间的所有偶数。
在main方法启动上述两个线程同时执行,主线程等待两个线程终止。

继承的方式实现案例编程

//子线程的继承类
**package com.lagou.task18;**
**public class SubThread1 extends Thread {**
** @Override**
** public void run() {**
** // 打印1 ~ 100之间的所有奇数**
** for (int i = 1; i <= 100; i += 2) {**
** System.out.println("子线程一中： i = " + i);**
** }**
** }**
**}**
//主线程的继承类
**package com.lagou.task18;**
**public class SubThread2 extends Thread {**
** @Override**
** public void run() {**
** // 打印1 ~ 100之间的所有偶数**
** for (int i = 2; i <= 100; i += 2) {**
** System.out.println("------子线程二中： i = " + i);**
** }**
** }**
**}**

继承方式的实现类
**package com.lagou.task18;**
**public class SubThreadTest {**
** public static void main(String[] args) {**
** SubThread1 st1 = new SubThread1();**
** SubThread2 st2 = new SubThread2();**
** st1.start();**
** st2.start();**
** System.out.println("主线程开始等待...");**
** try {**
** st1.join();**
** st2.join();**
** } catch (InterruptedException e) {**
** e.printStackTrace();**
** }**
** System.out.println("主线程等待结束！");**
** }**
**}**

接口的方式实现案例编程

//子线程的接口类
**package com.lagou.task18;**
**public class SubRunnable1 implements Runnable {**
** @Override**
** public void run() {**
** // 打印1 ~ 100之间的所有奇数**
** for (int i = 1; i <= 100; i += 2) {**
** System.out.println("子线程一中： i = " + i);**
** }**
** }**
**}**
//主线程的接口类
**package **``**task18**``**;<br />**``**public class **``**SubRunnable2 **``**implements **``**Runnable{**
** **``**@Override<br />**``** **``**public void **``**run**``**() {**
** **``**for **``**(**``**int **``**i = **``**2**``**;**``**i<= **``**100**``**;**``**i+=**``**2**``**){**
** System.**``**_out_**``**.println(**``**"+++**``**主线程中**``**i :"**``**+i)**``**;<br />**``** **``**}**
** }**
**}**

接口方式的实现类
package ``task18``;<br />``public class ``SubRunnableTest1 {
``public static void ``main``(String[] args) {
SubRunnable sr =``new ``SubRunnable()``;<br />`` ``SubRunnable2 sr2 = ``new ``SubRunnable2()``;<br />`` ``Thread t1 = ``new ``Thread(sr)``;<br />`` ``Thread t2 = ``new ``Thread(sr2)``;<br />`` ``t1.start()``;<br />`` ``t2.start()``;<br />`` ``System.``_out_``.println(``"``主线程开始等待``"``)``;<br />`` try ``{
t1.join()``;<br />`` ``t2.join()``;<br />`` ``} ``catch ``(InterruptedException e) {
e.printStackTrace()``;<br />`` ``}
System.``_out_``.println(``"``主线程等待结束``"``)``;<br />`` ``}
}