Thread类中的实例方法
从Thread类中的实例方法和类方法的角度讲解Thread中的方法,这种区分的角度也有助于理解多线程中的方法。实例方法,只和实例线程(也就是new出来的线程)本身挂钩,和当前运行的是哪个线程无关
1、start()
start()方法的作用讲得直白点就是通知"线程规划器",此线程可以运行了,正在等待CPU调用线程对象得run()方法,产生一个异步执行的效果
public class MyThread02 extends Thread
{
public void run()
{
try
{
for (int i = 0; i < 3; i++)
{
Thread.sleep((int)(Math.random() * 1000));
System.out.println("run = " + Thread.currentThread().getName());
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
MyThread02 mt = new MyThread02();
mt.start();
try
{
for (int i = 0; i < 3; i++)
{
Thread.sleep((int)(Math.random() * 1000));
System.out.println("run = " + Thread.currentThread().getName());
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
run = Thread-0
run = main
run = main
run = main
run = Thread-0
run = Thread-0
结果表明了:CPU执行哪个线程的代码具有不确定性
public class MyThread03 extends Thread
{
public void run()
{
System.out.println(Thread.currentThread().getName());
}
}
public static void main(String[] args)
{
MyThread03 mt0 = new MyThread03();
MyThread03 mt1 = new MyThread03();
MyThread03 mt2 = new MyThread03();
mt0.start();
mt1.start();
mt2.start();
}
Thread-1
Thread-2
Thread-0
尽管启动线程是按照mt0、mt1、mt2,但是实际的启动顺序却是Thread-1、Thread-2、Thread-0。这个例子说明了:调用start()方法的顺序不代表线程启动的顺序,线程启动顺序具有不确定性。
2、run()
线程开始执行,虚拟机调用的是线程run()方法中的内容 稍微改一下之前的例子看一下
public static void main(String[] args)
{
MyThread02 mt = new MyThread02();
mt.run();
try
{
for (int i = 0; i < 3; i++)
{
Thread.sleep((int)(Math.random() * 1000));
System.out.println("run = " + Thread.currentThread().getName());
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
run = main
run = main
run = main
run = main
run = main
run = main
说明如果只有run()没有start(),Thread实例run()方法里面的内容是没有任何异步效果的,全部被main函数执行。换句话说,只有run()而不调用start()启动线程是没有任何意义的。
3、isAlive()
测试线程是否处于活动状态,只要线程启动且没有终止,方法返回的就是true
/**
* isAlive()方法
*/
public class Thread_isAlive {
static class MyThread extends Thread{
@Override
public void run() {
System.out.println("run:"+Thread.currentThread().isAlive());
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
System.out.println("begin:"+myThread.isAlive());
myThread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end:"+myThread.isAlive());
}
begin:false
run:true
end:false
main函数中加上Thread.sleep(1000)的原因是为了确保Thread的run()方法中的代码执行完,否则有可能end这里打印出来的是true
4、isDaeMon、setDaemon(boolean on)
讲解两个方法前,首先要知道理解一个概念。Java中有两种线程,一种是用户线程,一种是守护线程。守护线程是一种特殊的线程,它的作用是为其他线程的运行提供便利的服务,最典型的应用便是GC线程。如果进程中不存在非守护线程了,那么守护线程自动销毁,因为没有存在的必要,为别人服务,结果服务的对象都没了,当然就销毁了。
理解了这个概念后,看一下例子
public class MyThread11 extends Thread
{
private int i = 0;
public void run()
{
try
{
while (true)
{
i++;
System.out.println("i = " + i);
Thread.sleep(1000);
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
try
{
MyThread11 mt = new MyThread11();
mt.setDaemon(true);
mt.start();
Thread.sleep(5000);
System.out.println("我离开thread对象再也不打印了,我停止了!");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
看一下运行结果:
1 i = 1
2 i = 2
3 i = 3
4 i = 4
5 i = 5
6 我离开thread对象再也不打印了,我停止了!
要解释一下。我们将MyThread11线程设置为守护线程,看到第6行的那句话,而i停在6不会再运行了。这说明,main线程运行了5秒多结束,而i每隔1秒累加一次,5秒后main线程执行完结束了,MyThread11作为守护线程,main函数都运行完了,自然也没有存在的必要了,就自动销毁了,因此也就没有再往下打印数字。
关于守护线程,有一个细节注意下,setDaemon(true)必须在线程start()之前
5、getPriority() setPriority(int newPriority)
java线程优先级
JAVA线程的优先级取值范围是1 (Thread.MIN_PRIORITY ) 到 10 (Thread.MAX_PRIORITY )。如果没有设置, 线程默认的优先级是NORM_PRIORITY。这个值是5。
优先级高的CPU得到的CPU资源比较多,设置优先级有助于帮"线程规划器"确定下一次选择哪一个线程优先执行。换句话说,两个在等待CPU的线程,优先级高的线程越容易被CU选择执行。
/**
* 线程优先级
*/
public class Thread_priority {
static class MyThread01 extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+"优先级:"+Thread.currentThread().getPriority());
}
}
}
static class MyThread02 extends Thread{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+"优先级:"+Thread.currentThread().getPriority());
}
}
}
public static void main(String[] args) {
MyThread01 t1 = new MyThread01();
t1.setPriority(9);
t1.start();
MyThread02 t2 = new MyThread02();
t2.start();
}
}
Thread-0优先级:9
Thread-0优先级:9
Thread-0优先级:9
Thread-0优先级:9
Thread-0优先级:9
Thread-1优先级:5
Thread-1优先级:5
Thread-1优先级:5
Thread-1优先级:5
Thread-1优先级:5
线程的优先级是有一定的规则性的,CPU会尽量将执行资源让给优先级比较高的线程。
上面说到的第二点就是验证线程的规则性,在优先级越相近的情况,线程执行的顺序是随机的,CPU会尽量将执行资源让给优先级比较高的线程这一说法是对的,但是实际运行的情况是多种多样的,所以线程充满了随机性
Thread类中的静态方法
1、currentThread()
currentThread()方法返回的是对当前正在执行线程对象的引用
/**
* currentThread()
*/
public class Thread_currentThread extends Thread{
static{
System.out.println(Thread.currentThread().getName()+"--执行静态块");
}
public Thread_currentThread(){
System.out.println(Thread.currentThread().getName()+"--执行构造方法");
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--执行run方法");
}
public static void main(String[] args) {
Thread_currentThread t1= new Thread_currentThread();
t1.start();
}
}
main--执行静态块
main--执行构造方法
Thread-0--执行run方法
线程类的构造方法、静态块是被main线程调用的,而线程类的run()方法才是应用线程自己调用的
2、sleep(long millis)
sleep(long millis)方法的作用是在指定的毫秒内让当前"正在执行的线程"休眠(暂停执行)。这个"正在执行的线程"是关键,指的是Thread.currentThread()返回的线程。根据JDK API的说法,"该线程不丢失任何监视器的所属权",直白点讲,就是不让出CPU资源。CPU还在执行当前线程run()方法中的代码,sleep不会放开锁,无非执行的内容是"睡觉"而已。
/**
* sleep()休眠
*/
public class Thread_sleep extends Thread{
@Override
public void run() {
System.out.println(this.getName()+"--begin");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName()+"--end");
}
public static void main(String[] args) {
Thread_sleep t = new Thread_sleep();
t.start();
}
}
Thread-0--begin
Thread-0--end
begin后停顿2秒执行end
3、yield()
暂停当前执行的线程对象,并执行其他线程。这个暂停是会放弃CPU资源的,并且放弃CPU的时间不确定,有可能刚放弃,就获得CPU资源了,也有可能放弃好一会儿,才会被CPU执行。yield也不会放开锁。
public class MyThread08 extends Thread
{
public void run()
{
long beginTime = System.currentTimeMillis();
int count = 0;
for (int i = 0; i < 50000000; i++)
{
Thread.yield();
count = count + i + 1;
}
long endTime = System.currentTimeMillis();
System.out.println("用时:" + (endTime - beginTime) + "毫秒!");
}
}
public static void main(String[] args)
{
MyThread08 mt = new MyThread08();
mt.start();
}
用时:3264毫秒!
用时:3299毫秒!
用时:3232毫秒!
用时:3256毫秒!
用时:3283毫秒!
用时:3504毫秒!
用时:3378毫秒
看到,每次执行的用时都不一样,证明了yield()方法放弃CPU的时间并不确定。
4、interrupted()
测试当前线程是否已经中断,执行后具有将状态标识清除为false的功能。换句话说,如果连续两次调用该方法,那么返回的必定是false:
public class Thread_interrupted {
public static void main(String[] args) {
Thread.currentThread().interrupt();
System.out.println(Thread.currentThread().getName()+"是否中断:"+Thread.interrupted());
System.out.println(Thread.currentThread().getName()+"是否中断:"+Thread.interrupted());
System.out.println(Thread.currentThread().getName()+"是否中断:"+Thread.interrupted());
}
}
main是否中断:true
main是否中断:false
main是否中断:false