全部展开
线程启动62616964757 a 686964616 Fe 4b 893 e 5b 19e 3133361326332不仅仅是调用了你的RUN方法，而是一个线程调度器单独调用你所有线程的RUN方法。
我
他们的普通RUN方法必须执行完毕才能返回。 也就是说，会一直执行下去。 这样，RUN方法下的方法就不能执行了。 但是，线程中的RUN方法不同。 那是
只有一定的CPU时间，运行后传递给其他线程。 这样反复地切断CPU的时间。 切换很快，让我们觉得好像有很多线程在同时运行。
因为只简单地调用run方法没有作用，所以必须调用Thread类的start方法来启动线程。 因此，有两种方法可以启动线程
一个是写从Thread类继承的类，重写里面的run方法，用start方法启动线程
第二，编写类以实现Runnable接口，实现内部run方法，并使用newthread(runnabletarget ).start )方法启动它
这两种方法都需要实现RUN方法。 这样，当线程启动时，线程管理器就更容易调用你的RUN方法。
您的TestThread不是从Thread类继承的。 怎么会有开始方法呢？
有两种方法可以在java中实现多线程：继承Thread类和实现Runnable接口。
Thread类是在java.lang包中定义的。 一个类继承Thread类，同时保留本类的
run ) )方法可以实现多线程操作，但一个类只能继承一个父类。 这是这个方法的极限。
请看以下示例：
package org.thread.demo；
类我的thread extends thread {
私有字符串名称；
公共我的流(string name ) {
super (；
this.name=name；
}
公共语音运行(}
for(intI=0； i10； I ) {
System.out.println ('线程开始： ' this.name '，i=' i )；
}
}
}
package org.thread.demo；
public class ThreadDemo01 {
publicstaticvoidmain (string [ ] args ) {
MyThread mt1=new MyThread ('线程a )；
MyThread mt2=new MyThread (线程b )；
//thread1、thread2，按顺序进行
mt1.run (；
mt2.run (；
}
}
但是，在这种情况下，结果是有规律的，会执行第一个对象，然后执行第二个对象，并且不会相互执行。 在JDK文档中，可以看到当调用start ()方法时，将从JVM中检测run ()方法。 接下来启动
start ) )方法开始线程。
package org.thread.demo；
public class ThreadDemo01 {
publicstaticvoidmain (string [ ] args ) {
MyThread mt1=new MyThread ('线程a )；
MyThread mt2=new MyThread ('线程b )；
//按顺序进行
mt1.start (；
mt2.start (；
}
(；
这样，程序就能正常地交互运行。 那么，为什么必须使用start ()方法启动多线程呢？
在JDK安装路径中，src.zip是所有java源程序，在此代码中找到thread start (方法的定义后，您会发现它在此方法中使用
私有语音
开始0 (； 这里，native关键字意味着可以调用操作系统的基本函数，这样的技术可以使用JNI技术(
Interface )
Runnable接口
在实际开发中，多线程的操作很少使用Thread类，而是通过Runnable界面完成的。
public interface Runnable{
公共语音运行(；
}
示例：
package org.runnable.demo；
classmythreadimplementsrunnable {
私有字符串名称；
公共我的流(string name ) {
this.name
= name;}
public void run(){
for(int i=0;i<100;i++){
System.out.println("线程开始："+this.name+",i="+i);
}
}
};
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable target)
此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多
线程。(start()可以协调系统的资源):
package org.runnable.demo;
import org.runnable.demo.MyThread;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("线程a");
MyThread mt2=new MyThread("线程b");
new Thread(mt1).start();
new Thread(mt2).start();
}
}
· 两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比
继承Thread类有如下好处：
->避免点继承的局限，一个类可以继承多个接口。
->适合于资源的共享
以卖票程序为例，通过Thread类完成：
package org.demo.dff;
class MyThread extends Thread{
private int ticket=10;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
};
下面通过三个线程对象，同时卖票：
package org.demo.dff;
public class ThreadTicket {
public static void main(String[] args) {
MyThread mt1=new MyThread();
MyThread mt2=new MyThread();
MyThread mt3=new MyThread();
mt1.start();//每个线程都各卖了10张，共卖了30张票
mt2.start();//但实际只有10张票，每个线程都卖自己的票
mt3.start();//没有达到资源共享
}
}
如果用Runnable就可以实现资源共享，下面看例子：
package org.demo.runnable;
class MyThread implements Runnable{
private int ticket=10;
public void run(){
for(int i=0;i<20;i++){
if(this.ticket>0){
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
}
package org.demo.runnable;
public class RunnableTicket {
public static void main(String[] args) {
MyThread mt=new MyThread();
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
new Thread(mt).start();//个实例化对象mt，就会出现异常
new Thread(mt).start();
}
};
虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。
Runnable接口和Thread之间的联系：
public class Thread extends Object implements Runnable
发现Thread类也是Runnable接口的子类。
已赞过
已踩过<
你对这个回答的评价是？
评论
收起