线程的常用方法（1）

一、join()方法：执行该线程的方法进入阻塞状态，直到调用join方法的线程结束后，执行该方法的线程才会由阻塞状态转为就绪状态，再次与其他的线程争夺CPU的执行权，实例如下：

package com.jd.test;import java.util.Date;/*** * 计数器线程**/
class CounterThread extends Thread{private TimeThread timethread;public CounterThread(TimeThread timethread) {this.timethread=timethread;}@Overridepublic void run() {for (int i = 0; i < 3; i++) {if(i==1) {try {timethread.join();//此时执行该方法的是计数器线程，因此当执行到i==1的时候，计数器线程会进入阻塞状态，直到调用join方法的时间线程结束，计数器线程才会重新进入就绪状态} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("计数器线程");}}}/*** * 时间线程*/
class TimeThread extends Thread{@Overridepublic void run() {for (int i = 0; i <2; i++) {System.out.println("时间线程"+new Date());try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {TimeThread timethread = new TimeThread();timethread.start();new CounterThread(timethread).start();}
}

运行结果如图所示：

：特别注意：如果调用join()方法的线程，没有执行start方法，则永远不会执行该线程，实例如下：

package com.jd.test;import java.util.Date;/*** * 计数器线程**/
class CounterThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 3; i++) {if(i==1) {try {new TimeThread().join();//此时执行该方法的是计数器线程，由于时间线程么有调用start方法，因此不会执行时间线程；} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("计数器线程"+new Date());}}}/*** * 时间线程*/
class TimeThread extends Thread{@Overridepublic void run() {for (int i = 0; i <2; i++) {System.out.println("时间线程"+new Date());try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {new CounterThread().start();}
}

运行结果：

二、interrupt方法

实例：


package com.jd.test;import java.util.Date;/*** * 计数器线程**/
class CounterThread extends Thread {private TimeThread timeThread;public CounterThread(TimeThread timeThread){this.timeThread = timeThread;}@Overridepublic void run() {for(int i=1;i<=3; i++){if(i==2){try {timeThread.join();} catch (InterruptedException e) {System.out.println("计数器线程提前结束阻塞状态"+new Date());}}System.out.println("计数器线程："+i+":"+new Date());}}
}/*** * 时间线程*/
class TimeThread extends Thread{@Overridepublic void run() {for(int i=0;i<=2; i++){System.out.println("时间线程："+new Date());try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}}
}public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();timeThread.start();CounterThread counterThread = new CounterThread(timeThread);counterThread.start();try {Thread.sleep(15000);} catch (InterruptedException e) {e.printStackTrace();}counterThread.interrupt();//计数器线程执行该行代码后进入阻塞状态，时间线程至少需要消耗30秒才能结束，而15秒后计数器线程调用了interrupt方法致使该计数器线程提前结束阻塞状态。}
}

运行结果：

三、currentThread方法：返回当前正在执行的线程对象。

实例1：

package com.jd.test;public class Test {public static void main(String[] args) {Thread thread1 = Thread.currentThread();//当前执行main方法的线程对象是主线程System.out.println(thread1+"@@@@@@@@@@@@@@@@");Thread thread2 = new TimeThread();//当前执行的线程对象是时间线程，即输出的Thread-0System.out.println(thread2+"*****************");thread2.start();}
}class TimeThread extends Thread{@Overridepublic void run() {Thread thread = Thread.currentThread();//当前run方法的线程对象是时间线程，与Test中的时间线程是统一个线程，因此输出都是Thread-0System.out.println(thread+"&&&&&&&&&&&&&&&&");}
}

运行结果：

实例2：

public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();System.out.println("########"+timeThread);//输出时间线程，########Thread[Thread-0,5,main]timeThread.start();//此时执行run方法的线程对象是时间线程，因此输出@@@@@@@@Thread[Thread-0,5,main]timeThread.run();//可以看成只是普通类调用方法，有主线程执行，一次执行run方法的线程对象是主线程，输出为@@@@@@@@Thread[main,5,main]}
}class TimeThread extends Thread{@Overridepublic void run() {Thread thread = Thread.currentThread();System.out.println("@@@@@@@@"+thread);}
}

运行结果：

四、isAlive方法：判定该线程是否处于就绪、运行或阻塞状态，如果是则返回true，否则返回false。

实例

public class Test {public static void main(String[] args) {Thread thread = Thread.currentThread();new PrintThread(thread).start();//当执行该行代码时，打印线程会阻塞，此时会立马执行下一行代码，持续主线程并没有接受，因此输出为true,执行完输出语句，主线程结束，而此时打印线程并没有结束，因此输出为false,由此可证明，main方法中启动的线程可能晚于主线程结束System.out.println("$$$$$$$$$$$$$$$$$$main线程状态："+thread.isAlive());//这一行代码执行完，主线程也结束}
}class PrintThread extends Thread{private Thread thread;public PrintThread(Thread thread){this.thread = thread;}@Overridepublic void run() {try {sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.err.println("##############main线程状态："+thread.isAlive());//main方法中启动的线程可能晚于主线程结束}
}

运行结果:

五、setDaemon方法：用于将一个尚未调用线程start方法的线程设置为守护线程，守护线程会随着最后一个非守护线程的结束而结束，进程也会随着最后一个非守护线程的结束而结束，进程中所启动的其他非守护线程不会随着某一个非守护线程的结束而结束

public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();timeThread.setDaemon(true);//守护线程timeThread.start();}
}class TimeThread extends Thread{@Overridepublic void run() {while (true) {System.out.println(111);}}
}

六、void setPriority(int newPriority)：设置线程的优先级，优先级越高获得的执行次数越多

注意：同一个线程类创建的线程对象，优先级越高则可获得的执行次数越多；如果是不同的线程类创建的线程对象，优先级越高执行的次数不一定多，这与run()方法代码的复杂度有关

示例1：

public class Test {public static void main(String[] args) {TimeThread timeThread1 = new TimeThread("线程1");timeThread1.start();TimeThread timeThread2 = new TimeThread("线程2");//此时的线程1和线程2是同一个线程类创建的对象，run方法代码的复杂一样，把线程2的优先级设为10，优先级比线程1高，获得的执行次数也就越多timeThread2.setPriority(10);timeThread2.start();}
}class TimeThread extends Thread{public TimeThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i <5; i++) {System.out.println(getName()+":"+i);}}
}

示例2：

public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread("线程1");timeThread.start();CountThread countThread = new CountThread("线程2");//此时的线程1和线程2不是同一个线程类创建的对象，run方法代码的复杂不一样，就算把线程2的优先级设为10，优先级比线程1高，获得的执行次数也不一定多，它与代码的复杂度有关countThread.setPriority(10);countThread.start();}
}class TimeThread extends Thread{public TimeThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i <5; i++) {System.out.println(getName()+":"+new Date()+new Date()+new Date()+new Date()+new Date()+new Date()+new Date()+new Date());}}
}class CountThread extends Thread{public CountThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i <5; i++) {System.out.println(getName()+":"+i);}}
}

线程的常用方法（1）相关推荐

线程的常用方法——currentThread方法||在main方法中直接调用run（）方法，没有开启新的线程，以在run方法中的当前线程就是main线程||启动子线程，子线程会调用run方法
线程的常用方法--currentThread方法 Thread.currentThread()方法可以获得当前线程 Java 中的任何一段代码都是执行在某个线程当中的. 执行当前代码的线程就是当前线程 ...
java main是多线程的吗_Java多线程之线程及其常用方法
创建线程和常用方法进程与线程的概念进程进程是程序执行时的一个实例.程序运行时系统就会创建一个进程,并为它分配资源,然后把该进程放入进程就绪队列,进程调度器选中它的时候就会为它分配CPU时间,程序开 ...
java中的线程及常用方法
2.8 线程 2.8.1 线程的概念程序:保存在物理介质中的代码片段进程:正在进行当中的程序,就是操作系统的一个进程线程:一个程序当中一条独立的执行线索作用:只为让在同一时间做多件事,应对 ...
多线程(一)：创建线程和线程的常用方法
分享一个朋友的人工智能教程(请以"右键"->"在新标签页中打开连接"的方式访问).比较通俗易懂,风趣幽默,感兴趣的朋友可以去看看. 一:为什么要学多线程 ...
java学习（158）：线程的常用方法yield，优先级
//线程 public class test102 extends Thread{public void run(){while (true){System.out.println("我是线 ...
操作系统（3）-线程的六大状态、基于代码实战的线程创建及六个常用方法
一.进程和线程的简介进程的概念进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 进程中所包含的一个或多个执行单元成为线程.进程还拥有一个私 ...
【Java 语言】Java 多线程一 ( 线程基础 : 线程启动 | 线程停止 | 线程暂停 | 线程优先级 | 守护线程)
一. 线程启动线程启动 : -- 1. 继承 Thread 运行线程 : 重写 Thread 类的 run 方法, 然后执行该线程; -- 2. 实现 Runnable 接口, 并运行线程; -- ...
Java多线程（1）—线程初探
一.引言说到线程,经常会听到线程同步,首先是为什么要线程同步?什么是线程同步? 因为当有多个线程要同时访问一个变量或对象时,如果这些线程的执行(比如既有读又有写操作)时,就会导致变量值或对象的状态出 ...
Java里的线程控制
这篇文章接着上篇文章<<java 线程简介>> 写的. http://blog.csdn.net/nvd11/article/details/19118683 上一篇文章提到, ...
c++ 线程池_基础篇：高并发一瞥，线程和线程池的总结
进程是执行程序的实体,拥有独属的进程空间(内存.磁盘等).而线程是进程的一个执行流程,一个进程可包含多个线程,共享该进程的所有资源:代码段,数据段(全局变量和静态变量),堆存储:但每个线程拥有自己的执 ...

线程的常用方法（1）

线程的常用方法（1）相关推荐

最新文章

热门文章