Java多线程:多线程 Thread 类 中常用的方法的使用
每博一文案
日本有一位方丈曾在其寺庙的公告栏上写下一句标语: ”没有失败的人生才最失败。“
深以为然,不上高山,不知平地,不经大海,不懂宽阔的涵义,人生需要许多试错的机会,各种滋味需要亲自
尝过,才知酸甜苦辣,人有了经历,才会长阅历,有了阅历,才会逐渐成熟自如。
稻盛和夫曾说:”在富裕的现代生活中,我们很难让孩子历经艰辛。“正因为如此,我们才应该告诉他们塑造人格
最重要的是经历辛苦,而且我们必须让这种想法根植于理性之中。
不经一番寒彻骨,怎得梅花扑鼻香。你来时走过的每一步,都算数。哪怕是走了歪路,绕了远路,那些经过的风景,
偶然发现的新方向,浪费的时间。都会以你意想不到的方式,回馈与你。
这些或欢喜,或痛苦的经历,都将成为生命中不可复制的财富,助你奔向更美好的未来。
—————— 一禅心灵庙语
文章目录
该文章主要介绍:关于 Thread 类中的一些常用方法的 介绍 和 使用。
1. start( ) 介绍 与 使用
start( ) : 方法的作用是启动一个新线程,新线程会执行相应的run()方法。并且对于同一个对象的线程,不可以调用 start()方法两次不然会报异常 (IllegalThreadStateException
) 非法线程异常,仅仅只能调用一次start()方法。
Thread 类中的 start() 的源码:
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented.
*/
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
同一个线程调用一次 start()方法没有问题如下:
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 同一个线程对象,调用一次 start();
thread.start();
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
同一个线程对象,调用 start()方法两次会报错:的异常 IllegalThreadStateException
非法线程状态异常。 如下
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 同一个线程对象,调用一次 start();
thread.start();
// 同一个线程对象,调用两个 start();方法报错
thread.start(); // 报错
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
可以创建两个线程,分别调用 start()方法
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 同一个线程对象,调用一次 start();
thread.start();
// 创建第二个线程对象
Thread thread2 = new Thread(new MyThread5());
thread2.start();
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
2. run( ) 介绍 与 使用
run() : 就和普通的成员方法一样,可以被重复调用。单独调用**run()**的话,会在当前线程中执行run(),而并不会启动新线程!
Thread 中的 run ()方法其实重写 Runnable 中的 run()的抽象方法。
run(): 通常需要重写Thread()类/Runnable 中的抽象方法,将创建的线程要执行的操作声明在此方法中(线程实际要处理的事务)
Thread 中的run()方法的源码:
public class Thread implements Runnable {
/* What will be run. */
private Runnable target;
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}
}
Runnable 接口的源码:
package java.lang;
/**
* The <code>Runnable</code> interface should be implemented by any
* class whose instances are intended to be executed by a thread. The
* class must define a method of no arguments called <code>run</code>.
* <p>
* This interface is designed to provide a common protocol for objects that
* wish to execute code while they are active. For example,
* <code>Runnable</code> is implemented by class <code>Thread</code>.
* Being active simply means that a thread has been started and has not
* yet been stopped.
* <p>
* In addition, <code>Runnable</code> provides the means for a class to be
* active while not subclassing <code>Thread</code>. A class that implements
* <code>Runnable</code> can run without subclassing <code>Thread</code>
* by instantiating a <code>Thread</code> instance and passing itself in
* as the target. In most cases, the <code>Runnable</code> interface should
* be used if you are only planning to override the <code>run()</code>
* method and no other <code>Thread</code> methods.
* This is important because classes should not be subclassed
* unless the programmer intends on modifying or enhancing the fundamental
* behavior of the class.
*
* @author Arthur van Hoff
* @see java.lang.Thread
* @see java.util.concurrent.Callable
* @since JDK1.0
*/
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
直接调用 run() 方法并不会创建线程,仅仅只是一个方法之间的回调而已。
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.run();
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
2.1 start() 和 直接调用 run()的区别说明
- start() 方法会创建一个新线程,并由这个新线程启动调用 run()方法。
- 直接调用 run( ) 方法,并不会创建一个新线程而是由当前线程调用 run()方法,而且可以多次调用 run() 。
- 对于 start() 方法,同一个线程对象仅仅只能调用一次,调用第二次会报 :
IllegalThreadStateException
异常错误。
3. currentThread( ) 介绍 与 使用
currentThread() :是一个静态方法,作用:返回当前执行的线程的引用:类似于 this 这样的引用。
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread()); // // 返回当前执行的线程的引用
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread()); // 返回当前执行的线程的引用
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
4. getName( ) / setName( ) 介绍 与 使用
setName() :对象方法,设置线程的名称。
getName() :对象方法,获取到线程的名称
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
thread.setName("分支线程"); // 设置线程名
Thread.currentThread().setName("主线程"); // 设置主线程名,// 先通过Thread.currentThread()方法获取当前线程的引用
// main 主线程
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName());
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName());
}
}
}
5. yield( ) 介绍 与 使用
yield() 静态方法,作用:释放当前cpu执行的线程的占有的时间片(进入就绪状态), 注意虽然释放了:但是下一次cpu可能执行的还是这个我们(刚刚释放掉的线程),原因是:这个刚刚释放的线程又抢到(获取的)cpu的执行权限了。注意:yield() 并不会释放手中占有的锁 。
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
thread.setName("分支线程"); // 设置线程名
Thread.currentThread().setName("主线程"); // 设置主线程名,先通过Thread.currentThread()方法获取当前线程的引用
// main 主线程
for(int i = 0; i < 10; i++) {
Thread.yield(); // 释放当前线程占用的时间片,(进入就绪状态)
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
Thread.yield(); // 释放当前线程占用的时间片,(进入就绪状态)
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
6. sleep( ) 介绍 与 使用
sleep() 的作用是让当前线程休眠,即当前线程会从 “运行状态” 进入到 “休眠(阻塞)状态”。 sleep()会指定休眠时间,线程休眠的时间会 大于/等于 该休眠时间;在线程重新被唤醒时,它会由 "阻塞状态" 变成 “就绪状态”,从而 等待cpu的调度执行 。
sleep( long millis ) 中的的参数中的单位是:毫秒。注意还要处理一个异常。
Thread.sleep(1000 * 1); // 休眠 1 秒
Thread.sleep(1000 * 60); // 休眠 1 分钟
Thread.sleep(1000 * 60 * 60); // 休眠 1 小时
Thread.sleep(1000 * 60 * 60 * 24); // 休眠 一天
Thread.sleep(1000 * 60 * 60 * 24 * 365 ); // 休眠 1 年
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
thread.setName("分支线程"); // 设置线程名
Thread.currentThread().setName("主线程"); // 设置主线程名,先通过Thread.currentThread()方法获取当前线程的引用
// main 主线程
for(int i = 0; i < 10; i++) {
try {
Thread.sleep(1000 * 1 ); // 休眠 1 秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10; i++) {
try {
Thread.sleep(1000 * 1 ); // 休眠 1 秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
注意的是 sleep() 是静态方法,与对象无关,所以休眠的是当前执行的线程,不是调用的sleep()方法的对象线程。
如下,休眠的是 main 的主线程。
public class ThreadTest5 {
public static void main(String[] args) {
// 创建匿名实现 Runnable 的实现类
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
});
thread.start();
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(1000 * 1); // 休眠 1 秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
7. join( ) 介绍 与 使用
join() : 方法 作用是:让当前线程进入等待状态,不是对象调用 join()的对象线程进入等待状态,只有当调用 join()方法的对象线程执行完,当前等待状态的线程,才会往后执行。
如下:
当 main 主线程中的 for()循环中的 i == 5 的时候,main 主线程进入 等待状态 ,让调用 thread.join()的分支线程先执行完,main 主线程才可以从 等待状态 进入到 运行状态,继续执行 main 主线程后面的程序。
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
thread.setName("分支线程"); // 设置线程名
Thread.currentThread().setName("主线程"); // 设置主线程名,先通过Thread.currentThread()方法获取当前线程的引用
// main 主线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
if (i == 5) {
try {
thread.join(); // 当前线程停止,让 thread 分支线程执行完,再处理 Main 主线程中的程序
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
8. isAlive() 介绍 与 使用
isAlive() : 判断判断当前线程是否存活,如果存活 返回 true ,如果不存活,返回 false。
package blogs.blog4;
/**
* Thread 类中常用的一些方法的介绍和使用
*/
public class ThreadTest5 {
public static void main(String[] args) {
Thread thread = new Thread(new MyThread5());
// 直接调用 run()方法不会创建新的线程,仅仅只是方法之间的回调而已
thread.start();
thread.setName("分支线程"); // 设置线程名
Thread.currentThread().setName("主线程"); // 设置主线程名,先通过Thread.currentThread()方法获取当前线程的引用
// main 主线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
// 判断当前线程是否存活。
System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().isAlive()); //
if (i == 5) {
try {
thread.join(); // 当前线程停止,让 thread 分支线程执行完,再处理 Main 主线程中的程序
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thread.getName() + "-->" + thread.isAlive());
}
}
}
}
class MyThread5 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
9. 总结:
- start() : 启动当前线程,调用当前线程的run()方法,一个线程对象仅仅只能调用一次 start() 不然报:
IllegalThreadStateException
) 非法线程异常。 - run(): 通常需要重写Thread()类/Runnable 中的抽象方法,将创建的线程要执行的操作声明在此方法中(线程实际要处理的事务),直接调用 run()方法并不会创建新的线程,而是当前线程的简单的方法的调用,可以多次调用。
- currentThread():静态方法,返回当前执行的线程的引用
- .setName()设置线程名,getName()获取线程名:如果是设置主线程名的话,需要先获取到当前执行的线程的引用: Thread.currentThread()。因为main主线程没有继承 Thread 类,无法直接调用父类中的方法。
- yield() 静态方法,作用:释放当前cpu执行的线程的占有的时间片(进入就绪状态), 注意虽然释放了:但是下一次cpu可能执行的还是这个我们(刚刚释放掉的线程),原因是:这个刚刚释放的线程又抢到(获取的)cpu的执行权限了。注意:yield() 并不会释放手中占有的锁 。
- sleep() 的作用是让当前线程休眠,即当前线程会从 “运行状态” 进入到 “休眠(阻塞)状态”。 sleep()会指定休眠时间,线程休眠的时间会 大于/等于 该休眠时间;在线程重新被唤醒时,它会由 "阻塞状态" 变成 “就绪状态”,从而 等待cpu的调度执行 。sleep( long millis ) 中的的参数中的单位是:毫秒。注意还要处理一个异常。
- join() : 方法 作用是:让当前线程进入等待状态,不是对象调用 join()的对象线程进入等待状态,只有当调用 join()方法的对象线程执行完,当前等待状态的线程,才会往后执行。
- isAlive() : 判断判断当前线程是否存活,如果存活 返回 true ,如果不存活,返回 false。
10. 最后:
限于自身水平,其中存在的错误,希望大家给予指教,韩信点兵——多多益善,谢谢大家,后会有期,江湖再见 !!!