Java多线程运行机制
线程的生命周期及运行过程中的各个状态
- 新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。
- 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。
- 运行状态(Running): 线程获取CPU权限进行执行。run方法运行。需要注意的是,线程只能从就绪状态进入到运行状态。
- 阻塞状态(Blocked): 表示线程阻塞于锁。
- 等待状态(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
- 超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回。
- 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
Java实现多线程的3种方式
继承Thread类
新建FirstThread类,继承Thread类,重写run方法。
public class FirstThread extends Thread{
private String title;
public FirstThread(String title){
this.title = title;
}
@Override
public void run(){
for(int i = 0; i < 20; i++){
System.out.println(this.title+"运行:"+i);
}
}
}
实现Runnable接口
新建SecondThread类,实现Runnable接口,实现run方法。
public class SecondThread implements Runnable{
private String title;
public SecondThread(String title){
this.title = title;
}
@Override
public void run() {
for(int i = 0; i < 20; i++){
System.out.println(this.title+"运行:"+i);
}
}
Callable实现多线程
从最传统的开发来讲如果要进行多线程的实现肯定依靠的就是Runnable,但是Runnable接口有一个缺点:当线程执行完毕后,我们无法获取一个返回值,所以从JDK1.5之后就提出了一个新的线程实现接口:java.util.concurrent.Callable接口。
import java.util.concurrent.Callable;
/**
* 实现该接口可获得线程返回值
*/
public class ThirdThread implements Callable<String> {
private String title;
public ThirdThread(String title){
this.title = title;
}
@Override
public String call() throws Exception {
for(int i = 0; i < 20; i++){
System.out.println(this.title+"运行:"+i);
}
return this.title + "线程执行完成";
}
}
线程测试
import java.util.concurrent.FutureTask;
public class TestThread {
/**
* 实现多线程的三种方式
* @throws Exception
*/
@Test
public void test1() throws Exception{
// 1.继承Thread
FirstThread a = new FirstThread("A");
// 打印线程状态
System.out.println(a.getState());
a.start();
System.out.println(a.getState());
// 2.实现Runnable接口
SecondThread bTemp = new SecondThread("B");
Thread b = new Thread(bTemp);
b.start();
// 3.实现Callable接口,这种方式可以获取线程返回值
ThirdThread cTemp = new ThirdThread("C");
FutureTask futureTask = new FutureTask(cTemp);
Thread c = new Thread(futureTask);
c.start();
System.out.println(futureTask.get()+"");
}
}
运行结果:start方法让线程进入就绪状态,实际运行还需看CPU的调度
线程阻塞
对于线程的阻塞,考虑一下三个方面,不考虑IO阻塞的情况:睡眠; 等待; 因为需要一个对象的锁定而被阻塞。
线程睡眠
- 可通过Thread.sleep()的静态方法使线程进入阻塞状态,设置阻塞时间结束之后可重新进入就绪(可运行)状态。
- sleep设置的是阻塞的最短时间。阻塞时间结束之后不能保证线程马上运行。线程睡眠是帮助所有线程获得运行机会的最好方法。
- sleep()是静态方法,只能控制当前正在运行的线程。
public class SecondThread implements Runnable{
private String title;
public SecondThread(String title){
this.title = title;
}
@Override
public void run() {
try {
for(int i = 0; i < 20; i++){
if(i==1){
// 睡眠指定时间,并不能保证线程会精确地休眠到你指定的时间点
// 睡眠结束进入的是可执行状态,具体还需看CPU调度
Thread.sleep(1);
}
System.out.println(this.title+"运行:"+i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程的优先级
线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority()更改线程的优先级。
线程优先级为1~10之间的正整数,JVM从不会改变一个线程的优先级。然而,1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值,而将这些优先级进行每两个或多个合并,变成少于10个的优先级,则两个或多个优先级的线程可能被映射为一个优先级。
Thread thread = new Thread();
thread.setPriority(6);
thread.start();
线程默认优先级是5,Thread类中有三个常量,定义线程优先级范围:
static intMAX_PRIORITY:线程可以具有的最高优先级。
static intMIN_PRIORITY:线程可以具有的最低优先级。
static intNORM_PRIORITY:分配给线程的默认优先级。
注意:当设计多线程应用程序的时候,一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的,只能把线程优先级作用作为一种提高程序效率的方法,但是要保证程序不依赖这种操作。
线程让步yield()
- Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
- 线程总是存在优先级,优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下,当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
- yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
public class FirstThread extends Thread{
private String title;
public FirstThread(String title){
this.title = title;
}
@Override
public void run(){
for(int i = 0; i < 10; i++){
if(i==5){
Thread.yield();
}
System.out.println(this.title+"运行:"+i);
}
}
}
添加测试方法
@Test
public void test2(){
// 线程让步
FirstThread a = new FirstThread("A");
ThirdThread cTemp = new ThirdThread("C");
FutureTask futureTask = new FutureTask(cTemp);
Thread c = new Thread(futureTask);
// 设置相同的线程优先级(不可靠)
a.setPriority(6);
c.setPriority(6);
a.start();
c.start();
}
运行结果
join()方法
Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前,B不能工作。
另外,join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒,如果超过这个时间,则停止等待,变为可运行状态。
新建JoinThread类
public class JoinThread implements Runnable{
private Thread thread;
public JoinThread(Thread thread){
this.thread = thread;
}
@Override
public void run() {
try {
this.thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "尾部加入成功");
}
}
测试
/**
* 线程join
*/
@Test
public void test3(){
// Thread.currentThread表示当前代码段正在被哪个线程调用的相关信息
Thread previous = new FirstThread("first");
Thread thread = new Thread(new JoinThread(previous),"second");
thread.start();
previous.start();
}
运行结果
总结
以上就是Java实现多线程的三种方式及线程中关于线程阻塞基础方法的使用。这篇文章主要介绍了Java多线程的基础用法,关于多线程的知识远不止这些,为避免本文篇幅过长,关于多线程的其他知识点笔者会在接下来的文章中为大家介绍~~