在Java中要想实现多线程操作有两种方法:
(1) 继承Thread类
(2) 实现Runnable接口
一. 继承Thread类
Thread类是在java.lang包中定义的,一个类只要继承了Thread类,此类就称为多线程实现类。在Thread子类中,必须明确的覆写Thread类中的run方法,此方法为线程的主体。下面进行多线程的实现
【继承Thread类实现多线程】
class MyThread extends Thread {
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() { // 覆写Thread类中的run()方法
for (int i = 0; i < 10; i++) {
System.out.println(name + "运行,i=" + i);
}
}
};
public class TreadDemo01 {
public static void main(String[] args) {
MyThread mt1 = new MyThread("线程A");
MyThread mt2 = new MyThread("线程B");
mt1.start();
mt2.start();
}
}
运行的结果:
线程A运行,i=0
线程B运行,i=0
线程B运行,i=1
线程B运行,i=2
线程B运行,i=3
线程B运行,i=4
线程B运行,i=5
线程B运行,i=6
线程A运行,i=1
线程B运行,i=7
线程A运行,i=2
线程B运行,i=8
线程A运行,i=3
线程A运行,i=4
线程B运行,i=9
线程A运行,i=5
线程A运行,i=6
线程A运行,i=7
线程A运行,i=8
线程A运行,i=9
编译运行的结果可以看出两个线程对象是交错运行的,哪个线程对象抢到CPU资源,哪个线程就可以运行,所以程序每次运行的结果是不同的,在线程启动时调用的start()方法,但是实际上调用的是run()方法定义的主题。
注意:一个线程对象不能重复调用start()方法,否则会异常。
如果一个类只能靠继承Thread类才能实现多线程,则必定会受到单继承局限的影响,所以,一般要想实现多线程,还可以通过实现Runnable接口来完成。
二. 实现Runnable接口
在Java中也可以通过实现Runnable接口的方式来实现多线程,Runnable接口中定义了一个抽象方法:
public void run()
使用Runnable接口实现多线程:
class MyThread2 implements Runnable {
private String name;
public MyThread2(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(name + "运行,i=" + i);
}
}
}
以上代码时通过Runnable接口来实现多线程的,但是从前面的代码中可以知道,一个线程必须通过Thread类中的start()方法开启。如果继承了Thread类,则可以直接调用此方法,但是在实现Runnable接口时,此接口中并没有start()方法,那么该如何启动多线程?实际上,此时还是依靠Thread类完成的。
【使用Thread类来启动线程】
class MyThread2 implements Runnable {
private String name;
public MyThread2(String name) {
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(name + "运行,i=" + i);
}
}
}
public class RunnableDemo01 {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2("线程A");
MyThread2 mt2 = new MyThread2("线程B");
Thread th1 = new Thread(mt1);
Thread th2 = new Thread(mt2);
th1.start();
th2.start();
}
}
运行结果为:
线程A运行,i=0
线程B运行,i=0
线程B运行,i=1
线程B运行,i=2
线程B运行,i=3
线程B运行,i=4
线程B运行,i=5
线程B运行,i=6
线程B运行,i=7
线程B运行,i=8
线程B运行,i=9
线程A运行,i=1
线程A运行,i=2
线程A运行,i=3
线程A运行,i=4
线程A运行,i=5
线程A运行,i=6
线程A运行,i=7
线程A运行,i=8
线程A运行,i=9
以上两种方法可以发现,无论使用哪种方式,最终都必须依靠Thread类才能启动多线程。
三. Thread类和Runnable接口
通过Thread类和Runnable接口都可以实现多线程,那么两者有哪些联系和区别呐?下面观察Thread类的定义
public class Thread extends Object implements Runnable
从Thread类的定义可以发现,Thread类也是Runnable接口的子类,但在Thread类中并没有完全地实现Runnable接口中的run()方法。
Thread类的定义:
*/
public
class Thread implements Runnable {
/* Make sure registerNatives is the first thing <clinit> does. */
private static native void registerNatives();
static {
registerNatives();
}
public void run(){
if(target!=null){
target.run;
}
}
从定义中可以发现,在Thread类中的run()方法调用的Runnable接口中的run()方法,也就是说此方法是由Runnable子类完成的,所以如果要通过Thread类实现多线程,则必须覆写run()方法。
实际上Thread类和Runnable接口也是有区别的,如果一个类继承Thread类,则不适合于多个线程共享资源,而实现Runnable接口,就可以直接实现资源的共享。
【继承thread类而不能共享资源】
class MyThread extends Thread{ // 继承Thread类,作为线程的实现类
private int ticket = 5 ; // 表示一共有5张票
public void run(){ // 覆写run()方法,作为线程 的操作主体
for(int i=0;i<100;i++){
if(this.ticket>0){
System.out.println("卖票:ticket = " + ticket--) ;
}
}
}
};
public class ThreadDemo04{
public static void main(String args[]){
MyThread mt1 = new MyThread() ; // 实例化对象
MyThread mt2 = new MyThread() ; // 实例化对象
mt1.start() ; // 调用线程主体
mt2.start() ; // 调用线程主体
}
};
运行结果:
卖票:ticket=5
卖票:ticket=5
卖票:ticket=4
卖票:ticket=3
卖票:ticket=2
卖票:ticket=1
卖票:ticket=4
卖票:ticket=3
卖票:ticket=2
卖票:ticket=1
以上程序通过Thread类实现多线程,程序中实现了2个线程,但是两个线程分别买了各自的5张票,并没有达到资源共享的目的。
【实现Runnable接口可以资源共享】
class MyThread2 implements Runnable {
private int ticket = 5;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (ticket > 0) {
System.out.println("卖票:ticket=" + ticket--);
}
}
}
}
public class RunnableDemo01 {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2();
new Thread(mt1).start();
new Thread(mt1).start();
new Thread(mt1).start();
}
}
运行结果:
卖票:t这里写代码片
icket=5
卖票:ticket=4
卖票:ticket=2
卖票:ticket=3
卖票:ticket=1
从程序的运行结果可以发现,虽然启动了线程,但是3个线程一共才卖5张票,即ticket属性被所有属性被所有的行程对象共享。
可见,实现Runable接口相对于继承Thread类说,有如下显著的优势:
(1) 适合多个相同程序代码的线程去处理同一个资源的情况
(2) 可以避免由于Java单继承特性带来的局限
(3) 增强了程序的健壮性,代码能够被多个线程共享,代码与数据都是相互独立的
所以,在开发中建议使用Runnable接口实现多线程。