多线程2
10.3.线程中的常用操作方法
Java.lang.Thread类【线程类】
| void | start() 启动线程 |
| static Thread | currentThread()得到当前正在运行的线程对象 |
| String | getName()返回该线程的名称。 |
| void | setName(String name)设置线程名称
|
package com.wangxing.threadmehod1;
public class TestThread implements Runnable{
@Override
public void run() {
//static Thread currentThread()得到当前正在运行的线程对象
Thread th=Thread.currentThread();
//String getName()返回该线程的名称。
String thname=th.getName();
for(int i=1;i<=100;i++){
System.out.println(thname+"--i=="+i);
}
}
}package com.wangxing.threadmehod1;
public class TestMain {
public static void main(String[] args) {
TestThread testthread=new TestThread();
Thread th1=new Thread(testthread);
Thread th2=new Thread(testthread);
/*
void setName(String name)设置线程名称
1.当没有设置线程名称的时候，系统会赋予线程一个默认的名称“Thread-0,Thread-1......”
*/
th1.setName("线程1");
th2.setName("线程2");
// void start() 启动线程
th1.start();
th2.start();
//2.主线程【主方法的执行线程】的名称默认是“main”
String name=Thread.currentThread().getName();
System.out.println("主线程名称=="+name);
}
}| int | getPriority() 返回线程的优先级。 |
| void | setPriority(int newPriority) 更改线程的优先级。 |
线程的优先级--就是线程的执行先后。
1.线程的优先级有10个级别，分别使用整数1~10来表示。
为了方便操作，java将10个级别有规定成3个级别，分别是最低的优先级，中等优先级，最高的优先级，并且将这3个级别封装成了静态常量.
2.设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。优先级越高并代表就一定会优先执行，只是被优先执行的几率增大，因此不要试图通过控制线程的优先级，来保证某一个线程，总是第一个执行。
3.所有线程默认的优先级都是5【中等级别】
package com.wangxing.threadmehod2;
public class TestThread implements Runnable{
@Override
public void run() {
//static Thread currentThread()得到当前正在运行的线程对象
Thread th=Thread.currentThread();
//String getName()返回该线程的名称。
String thname=th.getName();
for(int i=1;i<=100;i++){
System.out.println(thname+"--i=="+i);
}
}
}package com.wangxing.threadmehod2;
public class TestMain {
public static void main(String[] args) {
TestThread testthread=new TestThread();
Thread th1=new Thread(testthread);
Thread th2=new Thread(testthread);
th1.setName("线程1");
th2.setName("线程2");
//void setPriority(int newPriority) 更改线程的优先级。
//1.线程的优先级有10个级别，分别使用整数1~10来表示。
//为了方便操作，java将10个级别有规定成3个级别，分别是最低的优先级，中等优先级，最高的优
//先级，
//并且将这3个级别封装成了静态常量
//th1.setPriority(1);
//th2.setPriority(10);
//Thread.currentThread().setPriority(5);
th1.setPriority(Thread.MIN_PRIORITY);
th2.setPriority(Thread.MAX_PRIORITY);
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
// int getPriority() 返回线程的优先级。
//所有线程默认的优先级都是5【中等级别】
System.out.println(th1.getName()+"优先级是="+th1.getPriority());
System.out.println(th2.getName()+"优先级是="+th2.getPriority());
//得到主线程的名称
String name=Thread.currentThread().getName();
//得到主线程的名称优先级
int pri=Thread.currentThread().getPriority();
System.out.println(name+"优先级是="+pri);
//2.设置线程的优先级的时候，数字越大优先级越高，数字越小优先级越低。
//优先级越高并代表就一定会优先执行，只是被优先执行的几率增大，
//因此不要试图通过控制线程的优先级，来保证某一个线程，总是第一个执行。
th1.start();
th2.start();
}
}守护线程的相关操作方法:
通常情况之下我们所创建的线程都是普通线程，非守护线程，也叫用户线程。守护线程，也叫精灵线程【当所有用户线程都执行完毕以后，自动结束运行的线程就是守护线程】
特征：当所有用户线程都执行完毕以后，无论守护线程能否可以继续运行，都要立刻停止运行。可以理解为‘不是同年同月同日生，但是一定会同年同月同日死【共死/陪葬】’。
| boolean | isDaemon() 测试该线程是否为守护线程。 |
| void | setDaemon(boolean on) 将该线程标记为守护线程用户线程。 |
package com.wangxing.threadmehod3;
public class TestThread implements Runnable{
@Override
public void run() {
//static Thread currentThread()得到当前正在运行的线程对象
Thread th=Thread.currentThread();
//String getName()返回该线程的名称。
String thname=th.getName();
for(int i=1;i<=100;i++){
try {
Thread.sleep(400); //设置间隔0.4秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thname+"--i=="+i);
}
}
}package com.wangxing.threadmehod3;
public class ShouHuThread implements Runnable{
@Override
public void run() {
//static Thread currentThread()得到当前正在运行的线程对象
Thread th=Thread.currentThread();
//String getName()返回该线程的名称。
String thname=th.getName();
while(true){
try {
Thread.sleep(400); //设置间隔0.4秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thname);
}
}
}package com.wangxing.threadmehod3;
public class TestMain {
public static void main(String[] args) {
TestThread testthread=new TestThread();
ShouHuThread shouhuthread=new ShouHuThread();
Thread th1=new Thread(testthread);
Thread th2=new Thread(shouhuthread);
th1.setName("用户线程");
th2.setName("守护线程");
//void setDaemon(boolean on) 将该线程标记为守护线程用户线程。
th2.setDaemon(true);
//boolean isDaemon() 测试该线程是否为守护线程。
System.out.println(th1.getName()+"-isDaemon="+th1.isDaemon());
System.out.println(th2.getName()+"-isDaemon="+th2.isDaemon());
//特征：当所有用户线程都执行完毕以后，无论守护线程能否可以继续运行，都要立刻停止运行。
th1.start();
th2.start();
}
}| static void | sleep(long millis) 设置线程休眠【暂停】指定的时间【毫秒】 |
| void | interrupt() 中断线程休眠【暂停】。 |
package com.wangxing.test3;
public class MyTestThread implements Runnable{
@Override
public void run() {
String name=Thread.currentThread().getName();
System.out.println(name+"开始听讲");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name+"进入梦乡......");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println(name+"被老师一脚踹醒");
System.out.println(name+"又开始听讲");
try {
Thread.sleep(5000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
System.out.println("下课啦！");
}
}
}package com.wangxing.test3;
public class TestMain {
public static void main(String[] args) {
System.out.println("上课铃响啦");
Thread th=new Thread(new MyTestThread());
th.setName("小明");
th.start();
System.out.println("老师开始上课");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("老师发现同学睡着啦");
System.out.println("老师走过去，踹了一脚!");
th.interrupt();
}
}package com.wangxing.test3;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class NaoZhong {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请设置一个闹钟时间:");
String setTime=input.nextLine();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
boolean flag=true;
while(flag) {
String newtime=sdf.format(new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(newtime);
if(newtime.equals(setTime)) {
System.out.println("闹钟响铃!!!!!!");
flag=false;
}
}
}
}| void | join(long millis)等待该线程终止的时间最长为 millis 毫秒。【强制线程执行】 |
package com.wangxing.threadmehod5;
public class TestThread implements Runnable{
@Override
public void run() {
//static Thread currentThread()得到当前正在运行的线程对象
Thread th=Thread.currentThread();
//String getName()返回该线程的名称。
String thname=th.getName();
for(int i=1;i<=100;i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thname+"--i=="+i);
}
}
}package com.wangxing.threadmehod5;
public class TestMain {
public static void main(String[] args) {
Thread th=new Thread(new TestThread());
th.setName("小明");
th.start();
//得到主线程的名称
String mainname=Thread.currentThread().getName();
for(int j=1;j<=100;j++){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(mainname+"--j=="+j);
if(j==10){
// void join(long millis)等待该线程终止的时间最长为 millis 毫秒。【强制线程执行】
try {
th.join(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}10.4.线程的生命周期
- 线程的生命周期就是线程从一开始创建，到run方法执行完毕以后的状态变化。[状态之间的切换]
2.线程的生命周期几种状态【1、新建状态 2、就绪状态 3、运行状态 4.阻塞状态 5.死亡状态】
创建状态：通过new的方式创建出线程对象，此时线程就进入到创建状态【新建状态】。
新建状态的线程是不能运行。
就绪状态：新建状态的线程调用strat方法之后就会进入就绪状态。 就绪状态的线程具备执行能力，但是没有cpu资源。【万事具备只差cpu】.
运行状态：就绪状态的线程得到cpu资源开始执行run方法，此时这个线程就是运行状态。 运行状态的线程当cpu切换到其他线程时候，本线程就再一次进入就绪状态。
阻塞状态：运行状态的线程调用sleep/wait方法......此时线程进入阻塞状态。处于阻塞状态的线程的休眠时间到/调用notify方法/notifyAll方法在此时线程进 入就绪状态，从就绪状态中得到cpu资源从而进入运行状态。
死亡状态：运行状态的线程run方法运行结束/线程执行过程中遇到异常/调用stop方法此时线程就进入到死亡状态。死亡状态的线程是不能运行，除非再一次使用strat方法重新启动运行。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
