java多线程实现
实现多线程的前提:有一个线程的执行主类。(与main()函数类似,是线程启动的入口。)
如果现在要想实现一个多线程的主类,有两个途径:
1. 继承一个Thread类;(有单继承局限)
2. 【推荐】实现Runnable、Callable接口。
本篇的总结:无论是用Thread类、Runnable接口还是Callable接口,其实都是去找多线程的启动方法(start()方法)去启动多线程。
一、Thread类实现多线程
java.lang.Thread是一个线程操作的核心类。定义一个线程的主类,最简单的方法就是直接继承Thread类,然后覆写该类中的run()方法(相当于线程的主方法)。
但是不能直接调用run()方法(只调用run()方法的话,就相当于对每个线程分别进行了顺序打印,不会出现线程的交替执行),正确启动多线程的方式应该是调用Thread类中的start()方法,通过start()方法调用run()方法(见下图)
启动多线程:public void start();调用此方法会调用run()方法。
代码示例:
package cn.edu.www;
class MyThread extends Thread{//是一个线程主题类
private String title;
public MyThread(String title) {
this.title=title;
}
@Override
public void run() {
for (int x=0;x<6;x++) {
System.out.println(this.title+": x="+x);
}
}
}
public class TestDemo {
public static void main(String[] args) {
MyThread p1=new MyThread("线程A");
MyThread p2=new MyThread("线程B");
MyThread p3=new MyThread("线程C");
p1.start();
p2.start();
p3.start();
}
}
运行结果:(三个线程是交替执行的,而不是各自执行各自的。每运行一次,结果会不同)
线程B: x=0
线程A: x=0
线程C: x=0
线程A: x=1
线程B: x=1
线程B: x=2
线程B: x=3
线程B: x=4
线程B: x=5
线程A: x=2
线程C: x=1
线程C: x=2
线程C: x=3
线程C: x=4
线程C: x=5
线程A: x=3
线程A: x=4
线程A: x=5
问题:为什么要通过start()方法调用run()方法呢?
从java的源代码(在JDK的安装目录下->src.zip->java->lang->Thread.java)中找答案。
代码很多,直接看关于start()方法的源代码如下:
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
private native void start0();
解释源代码:
1. 异常的抛出:IllegalThreadStateException,此异常是一个RuntimeException的子类。(当重复启动了多线程时就会出现此异常)
2. 最后一行是一个start0()方法,是一个只声明未实现的方法,并且用关键字native进行定义,native指的是调用本机的原生系统函数。这个方法是由不同操作系统版本的JVM实现。所以native在该情况下指的就是该操作将交由本地操作系统进行支持。这就是为什么通过start()调用run()方法的原因。
二、使用Runnable接口实现多线程
Thread类的核心功能是进行线程的启动,但是Thread类具有单继承局限,所以java提供了另外一种实现模式:Runnable接口。
在JDK文档中查找Runnable接口定义:该接口是一个函数式接口,只存在一个run()方法。
@FunctionalInterface
public interface Runnable{
public void run();
}
虽然解决了单继承问题,但是没有了start()方法被继承了。那么此时就需要关注Thread类提供的构造方法,以此找到可以使用start()方法的途径,得以启动多线程:
- 构造方法:public Thread(Runnable target),可以接收Runnable接口对象,就意味着可以通过Thread类启动多线程。
代码示例:用Runnable接口启动多线程
class MyThread implements Runnable{//是一个线程主题类
private String title;
public MyThread(String title) {
this.title=title;
}
@Override
public void run() {
for (int x=0;x<6;x++) {
System.out.println(this.title+": x="+x);
}
}
}
public class TestDemo {
public static void main(String[] args) {
MyThread p1=new MyThread("线程A");
MyThread p2=new MyThread("线程B");
MyThread p3=new MyThread("线程C");
new Thread(p1).start();//应用Thread的构造方法,启动多线程
new Thread(p2).start();
new Thread(p3).start();
}
}
运行结果:
线程B: x=0
线程B: x=1
线程B: x=2
线程B: x=3
线程B: x=4
线程B: x=5
线程A: x=0
线程A: x=1
线程A: x=2
线程C: x=0
线程C: x=1
线程C: x=2
线程A: x=3
线程C: x=3
线程C: x=4
线程C: x=5
线程A: x=4
线程A: x=5
由以上代码可以知道,多线程的启动永远都是Thread类的start()方法!!!
注:对于Runnable接口对象也可以采用匿名内部类或者Lambda表达式类进行定义。
代码示例1:匿名内部类
public class TestDemo {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello!");
}
}).start();
}
}
代码示例2:Lambda表达式
public class TestDemo {
public static void main(String[] args) {
new Thread(()->System.out.println("hello!")).start();
}
}
三、Thread与Runnable的区别
使用形式上:使用Runnable实现多线程会更好,因为避免了单继承的局限。
除此之外,Thread和Runnable之间存在着一些联系。观察Thread类的定义形式:(JDK文档)
public class Thread extends Object implements Runnable
Thread类是Runnable接口的子类,所以Thread类覆写了run()方法。
Thread类覆写run()方法的源代码:
public void run() {
if (target != null) {
target.run();
}
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
private Runnable target;
所以结合之前的程序代码就可以形成如下的类继承结构:
所以在多线程的处理上使用的就是代理设计模式!!!
四、线程的运行状态(面试题)
线程的启动使用的是start()方法,但是并不意味着调用了start()方法就立刻调用多线程。
当多线程调用了start()方法之后并不是立刻执行,而是进入到就绪状态,等待进行调度后执行,当分配到资源后,才可以执行多线程的代码(run()中的代码),当执行了一段时间之后,就要让出资源,让其他线程继续执行,也就是说run()方法可能还没执行完,只执行了一部分,就要让出资源,重新进入就绪状态,重新等待分配新资源再继续执行。当线程执行完毕后才会进入到终止状态。
五、Callable实现多线程
在JDK1.5之后追加了一个新的开发包:java.util.concurrent,这个开发包主要是进行高性能编程使用的,也就是在这个开发包中会提供一些高并发操作中才会使用到的类。这个包中定义有一个新的接口:
@FunctionalInterface
public interface Callable<V>{
public V call() throws Exception;
}
注意:Runnable接口中的run()方法是线程的主方法,可以启动线程,那么和Callable接口中的call()方法有什么区别呢?
答:Runnable接口中的run()方法没有返回值,而Callable接口中的call()方法是有返回值的。
但是只有Thread类中的start()方法可以启动多线程。首先了分析一下Callable接口的定义:
代码示例:使用Callable启动多线程的方法
import java.util.concurrent.Callable;
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
for (int x=0;x<10;x++) {
System.out.println("cat="+x);
}
return "猫";
}
}
public class TestDemo {
public static void main(String[] args) throws Exception{
FutureTask<String> task=new FutureTask<String>(new MyThread());
new Thread(task).start();
System.out.println(task.get());
}
}
运行结果:
cat=0
cat=1
cat=2
cat=3
cat=4
cat=5
cat=6
cat=7
cat=8
cat=9
猫