Java多线程2：Thread中的实例方法

Thread类中的方法调用方式：

学习Thread类中的方法是学习多线程的第一步。在学习多线程之前特别提出一点，调用Thread中的方法的时候，在线程类中，有两种方式，一定要理解这两种方式的区别：

1、this.XXX()

这种调用方式表示的线程是线程实例本身

2、Thread.currentThread.XXX()或Thread.XXX()

上面两种写法是一样的意思。这种调用方式表示的线程是正在执行Thread.currentThread.XXX()所在代码块的线程

当然，这么说，肯定有人不理解两者之间的差别。没有关系，之后会讲清楚，尤其是在讲Thread构造函数这块。讲解后，再回过头来看上面2点，会加深理解。

Thread类中的实例方法

从Thread类中的实例方法和类方法的角度讲解Thread中的方法，这种区分的角度也有助于理解多线程中的方法。实例方法，只和实例线程（也就是new出来的线程）本身挂钩，和当前运行的是哪个线程无关。看下Thread类中的实例方法：

1、start()

start()方法的作用讲得直白点就是通知"线程规划器"，此线程可以运行了，正在等待CPU调用线程对象得run()方法，产生一个异步执行的效果。通过start()方法产生得到结论，先看下代码：

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();}
}

MyThread02的代码不变，看下运行结果：

run = main
run = main
run = main
run = main
run = main
run = main

看到打印了6次的"run = main"，说明如果只有run()没有start()，Thread实例run()方法里面的内容是没有任何异步效果的，全部被main函数执行。换句话说，只有run()而不调用start()启动线程是没有任何意义的。

3、isAlive()

测试线程是否处于活动状态，只要线程启动且没有终止，方法返回的就是true。看一下例子：

public class MyThread06 extends Thread
{public void run(){System.out.println("run = " + this.isAlive());}
}

public static void main(String[] args) throws Exception
{MyThread06 mt = new MyThread06();System.out.println("begin == " + mt.isAlive());mt.start();Thread.sleep(100);System.out.println("end == " + mt.isAlive());
}

看下运行结果：

begin == false
run = true
end == false

看到在start()之前，线程的isAlive是false，start()之后就是true了。main函数中加上Thread.sleep(100)的原因是为了确保Thread06的run()方法中的代码执行完，否则有可能end这里打印出来的是true，有兴趣可以自己试验一下。

4、getId()

这个方法比较简单，就不写例子了。在一个Java应用中，有一个long型的全局唯一的线程ID生成器threadSeqNumber，每new出来一个线程都会把这个自增一次，并赋予线程的tid属性，这个是Thread自己做的，用户无法执行一个线程的Id。

5、getName()

这个方法也比较简单，也不写例子了。我们new一个线程的时候，可以指定该线程的名字，也可以不指定。如果指定，那么线程的名字就是我们自己指定的，getName()返回的也是开发者指定的线程的名字；如果不指定，那么Thread中有一个int型全局唯一的线程初始号生成器threadInitNum，Java先把threadInitNum自增，然后以"Thread-threadInitNum"的方式来命名新生成的线程

6、getPriority()和setPriority(int newPriority)

这两个方法用于获取和设置线程的优先级，优先级高的CPU得到的CPU资源比较多，设置优先级有助于帮"线程规划器"确定下一次选择哪一个线程优先执行。换句话说，两个在等待CPU的线程，优先级高的线程越容易被CU选择执行。下面来看一下例子，并得出几个结论：

public class MyThread09_0 extends Thread
{public void run(){System.out.println("MyThread9_0 run priority = " + this.getPriority());}
}

public class MyThread09_1 extends Thread
{public void run(){System.out.println("MyThread9_1 run priority = " + this.getPriority());MyThread09_0 thread = new MyThread09_0();thread.start();}
}

public static void main(String[] args)
{System.out.println("main thread begin, priority = " + Thread.currentThread().getPriority());System.out.println("main thread end, priority = " + Thread.currentThread().getPriority());MyThread09_1 thread = new MyThread09_1();thread.start();
}

看一下运行结果：

main thread begin, priority = 5
main thread end, priority = 5
MyThread9_1 run priority = 5
MyThread9_0 run priority = 5

从这个例子我们得出结论：线程默认优先级为5，如果不手动指定，那么线程优先级具有继承性，比如线程A启动线程B，那么线程B的优先级和线程A的优先级相同。下面的例子演示了设置线程优先级带来的效果：

public class MyThread10_0 extends Thread
{public void run(){long beginTime = System.currentTimeMillis();for (int j = 0; j < 100000; j++){}long endTime = System.currentTimeMillis();System.out.println("◆◆◆◆◆ thread0 use time = " + (endTime - beginTime));}
}

public class MyThread10_1 extends Thread
{public void run(){long beginTime = System.currentTimeMillis();for (int j = 0; j < 100000; j++){}long endTime = System.currentTimeMillis();System.out.println("◇◇◇◇◇ thread1 use time = " + (endTime - beginTime));}
}

public static void main(String[] args)
{for (int i = 0; i < 5; i++){MyThread10_0 mt0 = new MyThread10_0();mt0.setPriority(5);mt0.start();MyThread10_1 mt1 = new MyThread10_1();mt1.setPriority(4);mt1.start();}
}

看下运行结果：

◆◆◆◆◆ thread0 use time = 0
◆◆◆◆◆ thread0 use time = 0
◆◆◆◆◆ thread0 use time = 1
◆◆◆◆◆ thread0 use time = 2
◆◆◆◆◆ thread0 use time = 2
◇◇◇◇◇ thread1 use time = 0
◇◇◇◇◇ thread1 use time = 1
◇◇◇◇◇ thread1 use time = 5
◇◇◇◇◇ thread1 use time = 2
◇◇◇◇◇ thread1 use time = 0

看到黑色菱形（线程优先级高的）先打印完，再多试几次也是一样的。为了产生一个对比效果，把yMyThread10_0的优先级设置为4，看下运行结果：

◆◆◆◆◆ thread0 use time = 0
◇◇◇◇◇ thread1 use time = 1
◇◇◇◇◇ thread1 use time = 1
◆◆◆◆◆ thread0 use time = 0
◇◇◇◇◇ thread1 use time = 0
◆◆◆◆◆ thread0 use time = 1
◆◆◆◆◆ thread0 use time = 1
◇◇◇◇◇ thread1 use time = 2
◇◇◇◇◇ thread1 use time = 1
◆◆◆◆◆ thread0 use time = 0

看到，马上差别就出来了。从这个例子我们得出结论：CPU会尽量将执行资源让给优先级比较高的线程。

7、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 = 12 i = 23 i = 34 i = 45 i = 56 我离开thread对象再也不打印了，我停止了！

要解释一下。我们将MyThread11线程设置为守护线程，看到第6行的那句话，而i停在6不会再运行了。这说明，main线程运行了5秒多结束，而i每隔1秒累加一次，5秒后main线程执行完结束了，MyThread11作为守护线程，main函数都运行完了，自然也没有存在的必要了，就自动销毁了，因此也就没有再往下打印数字。

关于守护线程，有一个细节注意下，setDaemon(true)必须在线程start()之前

8、interrupt()

这是一个有点误导性的名字，实际上Thread类的interrupt()方法无法中断线程。看一下例子：

public class MyThread12 extends Thread
{

　　public void run()
　　{
　　　　for (int i = 0; i < 500000; i++)
　　　　{
　　　　　　System.out.println("i = " + (i + 1));
　　　　}
　　}

　　public static void main(String[] args)
　　{
　　　　try
　　　　{
　　　　　　MyThread12 mt = new MyThread12();
　　　　　　mt.start();
　　　　　　Thread.sleep(2000);
　　　　　　mt.interrupt();
　　　　}
　　　　　　catch (InterruptedException e)
　　　　{
　　　　　　e.printStackTrace();
　　　　}
　　}

看下运行结果：

...i = 499995
i = 499996
i = 499997
i = 499998
i = 499999
i = 500000

看结果还是打印到了50000。也就是说，尽管调用了interrupt()方法，但是线程并没有停止。interrupt()方法的作用实际上是：在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞状态。换句话说，没有被阻塞的线程，调用interrupt()方法是不起作用的。关于这个会在之后讲中断机制的时候，专门写一篇文章讲解。

9、isInterrupted()

测试线程是否已经中断，但不清除状态标识。这个和interrupt()方法一样，在后面讲中断机制的文章中专门会讲到。

10、join()

join()方法的作用是等待线程销毁。join()方法反应的是一个很现实的问题，比如main线程的执行时间是1s，子线程的执行时间是10s，但是主线程依赖子线程执行完的结果，这时怎么办？可以像生产者/消费者模型一样，搞一个缓冲区，子线程执行完把数据放在缓冲区中，通知main线程，main线程去拿，这样就不会浪费main线程的时间了。另外一种方法，就是join()了。先看一下例子：

public class MyThread36 extends Thread
{public void run(){try{int secondValue = (int)(Math.random() * 10000);System.out.println(secondValue);Thread.sleep(secondValue);} catch (InterruptedException e){e.printStackTrace();}}
}

public static void main(String[] args) throws Exception
{MyThread36 mt = new MyThread36();mt.start();mt.join();System.out.println("我想当mt对象执行完毕之后我再执行，我做到了");
}

看一下运行结果：

3111
我想当mt对象执行完毕之后我再执行，我做到了

意思是，join()方法会使调用join()方法的线程（也就是mt线程）所在的线程（也就是main线程）无限阻塞，直到调用join()方法的线程销毁为止，此例中main线程就会无限期阻塞直到mt的run()方法执行完毕。

join()方法的一个重点是要区分出和sleep()方法的区别。join(2000)也是可以的，表示调用join()方法所在的线程最多等待2000ms，两者的区别在于：

sleep(2000)不释放锁，join(2000)释放锁，因为join()方法内部使用的是wait()，因此会释放锁。看一下join(2000)的源码就知道了，join()其实和join(2000)一样，无非是join(0)而已：

 1 public final synchronized void join(long millis) 2     throws InterruptedException {3     long base = System.currentTimeMillis();4     long now = 0;5 6     if (millis < 0) {7             throw new IllegalArgumentException("timeout value is negative");8     }9
10     if (millis == 0) {
11         while (isAlive()) {
12         wait(0);
13         }
14     } else {
15         while (isAlive()) {
16         long delay = millis - now;
17         if (delay <= 0) {
18             break;
19         }
20         wait(delay);
21         now = System.currentTimeMillis() - base;
22         }
23     }
24     }

第12行、第20行应该已经很清楚了。

转载于:https://www.cnblogs.com/xiaojiesir/p/10983196.html

Java多线程2：Thread中的实例方法相关推荐

delay在java中有什么用_DelayQueue怎么在Java多线程并发开发中使用
DelayQueue怎么在Java多线程并发开发中使用发布时间:2020-12-05 17:29:31 来源:亿速云阅读:56 作者:Leah 这篇文章给大家介绍DelayQueue怎么在Java ...
Java中Thread中的实例方法_Java多线程2：Thread中的实例方法
Thread类中的方法调用方式: 学习Thread类中的方法是学习多线程的第一步.在学习多线程之前特别提出一点,调用Thread中的方法的时候,在线程类中,有两种方式,一定要理解这两种方式的区别: 1 ...
java中thread实例_Java多线程2：Thread中的实例方法
Thread类中的方法调用方式: 学习Thread类中的方法是学习多线程的第一步.在学习多线程之前特别提出一点,调用Thread中的方法的时候,在线程类中,有两种方式,一定要理解这两种方式的区别: 1 ...
Java多线程，Thread，Runnable，Callable Task，Future＜Task＞，CompletionService
一.Java多线程的方法 1. 继承 Thread 2. 实现 Runnable 3. 实现 Callable 可以有返回值 package com.test;import java.util.Arr ...
java 多线程性能_Java中多线程的性能比较
java 多线程性能 Java中有多种用于多线程的技术. 可以通过同步关键字,锁或原子变量来并行化Java中的一段代码. 这篇文章将比较使用synced关键字ReentrantLock,getAndI ...
java多线程(一)-Thread类和Runnable接口
public class Thread extends Object implements Runnable Thread通过实现Runnable实现多态关系. Java中实现多线程,最基本2种方式: ...
java多线程区别_Java中实现多线程的两种方式之间的区别
Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线 ...
Java多线程（Thread）
/*并发:两个或多个事件在同一时间段内交替执行并行:两个或多个事件同时执行在计算机中,程序存储在硬盘中(ROM),但所有的应用程序都需要进入到内存(RAM)中执行.进程:进入到内存的程序线程:点击程序 ...
利用java多线程向MongoDB中批量插入静态文件
第一步.开发环境: win7 64位(注:MongoDb在32位windows上有数量限制(2G),详见官方文档) Mongodb3.2 mongofb_java_driver 3.2.2 第二部.安 ...

Java多线程2：Thread中的实例方法

Java多线程2：Thread中的实例方法相关推荐

最新文章

热门文章