本文目录
- Thread类和Runnable接口实现方式的区别
- Runnable接口详解
- 举例说明java中的runnable 接口实现线程,并启动线程的方法.
- java中Runnable接口含义
- 线程必须实现runnable接口吗
- 使用Runnable接口的方式创建线程,在线程中输出1-100的整数
- 为什么Runnable接口可创建对象
- Runnable接口中定义的方法是什么
Thread类和Runnable接口实现方式的区别
1 线程接口的实现有两种方式，第一：继承Thread类；第二：实现Runnnable接口；
2 两种创建方式上的不同：
建线程的第一种方式：继承Thread ，由子类复写run方法。
1，定义类继承Thread类；
2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；
3，通过创建Thread类的子类对象，创建线程对象；
4，调用线程的start方法，开启线程，并执行run方法。
创建线程的第二种方式：实现一个接口Runnable。
1，定义类实现Runnable接口。
2，覆盖接口中的run方法（用于封装线程要运行的代码）。
3，通过Thread类创建线程对象；
4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
3 下面是具体的代码展示两种方式创建线程：
继承Thread类创建线程的代码：
public class ThreadDemo {
public static void main(String args) {
// ThreadTest是继承了Thread类
ThreadTest t1=new ThreadTest (“ 1“);
t1.start();
}
}
//线程类 继承Thread类
public class ThreadTest extends Thread {
private int ticket=100;//每个线程都拥有100张票
public ThreadTest (){}
public ThreadTest (String name){
super(name);
}
@Override
public void run() {
while(ticket》0){
System.out.println(Thread.currentThread().getName());
}
}
}
实现Runnable 接口的方式：
class Person{
private int sum;
public void add(int n){
sum+=n;
System.out.println(“sum=“+sum);
}
}
//Person类实现Runnable接口
class Person implements Runnable{
private Person b=new Person ();
public void run(){
synchronized(b){
for(int x=0;x《3;x++)
{
b.add(100);
}
}
}
}
4 实际开发中一般使用Runnable接口的方式比较多，因为：
通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类
而实现Runnable接口可以避免单继承的局限性。
Runnable接口详解
在Java中，“线程”指两件不同的事情：
1、java.lang.Thread类的一个实例；
2、线程的执行。
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。
一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。
Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。
一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。
一旦创建一个新的线程，就产生一个新的调用栈。
线程总体分两类：用户线程和守候线程。
当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。
举例说明java中的runnable 接口实现线程,并启动线程的方法.
public class RunnableDemo {
public static void main(String args) throws Exception {
long statTime = System.currentTimeMillis();
SimpleRunnable runnable1 = new SimpleRunnable();
SimpleRunnable runnable2 = new SimpleRunnable();
// 每个 Thread（线程）可以接受一个 Runnable 的实现类做参数
// 线程启动时会去运行你实现的 run() 方法
Thread thread1 = new Thread(runnable1);
Thread thread2 = new Thread(runnable2);
thread1.start(); // 启动线程1
thread2.start(); // 启动线程2
thread1.join(); // 等待线程1运行结束
thread2.join(); // 等待线程2运行结束
long endTime = System.currentTimeMillis();
double time = (endTime - statTime) / 1000.0;
System.out.println(“程序运行时间： “ + time + “ 秒“);
// 每个任务运行时间都应该是 2 秒，但是因为你每个任务都用了一个线程去运行
// 所以这两个线程是同时（并发）进行的，所以这个程序只需要 2 秒左右就可以结束
}
}
// 写一个实现 Runnable 接口的类，并实现 run() 方法
class SimpleRunnable implements Runnable {
@Override
public void run() {
runTask(); // 运行你的任务
}
private void runTask() {
try {
Thread.sleep(2000); // 假设你的任务需要两秒完成
} catch (InterruptedException ex) {
ex.printStackTrace(System.err);
}
}
}
java中Runnable接口含义
java中Runnable接口：是一个接口，它里面只有一个run()方法，没有start()方法，继承Runnable并实现这个方法就可以实现多线程了，但是这个run()方法不能自己调用，必须由系统来调用。
举例如下：
[java] view plain copy
public interface Runnable{
public void run();
}
所以，即使实现了Runnable接口，那也无法启动线程，必须依托其他类。
而Thread类，有一个构造方法，参数是Runnable对象，也就是说可以通过Thread类来启动Runnable实现的多线程。
[java] view plain copy
public Thread(Runnable target) {
init(null, target, “Thread-“ + nextThreadNum(), 0);
}
所以，实现Runnable接口后，需要使用Thread类来启动。
线程必须实现runnable接口吗
要产生一个线程，有两种方法： 1、需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法； 2、实现Runnable接口，重载Runnable接口中的run()方法当然可以，这是是做线程的两个方法 创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。例如，计算大于某一规定值的质数的线程可以因为java不支持多重继承 当继承Thread类时,就不能继承其它类了 所以实现Runnable接口,就可以使该类继承其它类,以拥有更多的属性和方法Runnable是Thread的接口，在大多数情况下“推荐用接口的方式”生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。
在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程。
Thread Test = new Thread();
Test.start();
在使用Runnable的时候需要先new一个继承Runnable的实例，之后用子类Thread调用。
Test impelements Runnable
Test t = new Test();
Thread test = new Thread(t);
使用Runnable接口的方式创建线程,在线程中输出1-100的整数
package com.test;
public class TestRunnable {
public static void main(String args) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i 《= 100; i++) {
System.out.println(i);
}
}
}).run();
}
}
为什么Runnable接口可创建对象
这是匿名内部类的用法。匿名内部类可以不声明显式的对象而直接实例化抽象方法或者接口。你可以理解为这里实现了一个Runnable接口的对象，只不过该对象没有名字。
Runnable接口中定义的方法是什么
你可以比较一下创建线程的两个方法，继承thread类和实现runnable接口：
①
class
a
extends
thread
}
main()
②
class
a
implements
runnable
}
main()
注意看②里面的new
thread，你说的对，单独a实现了runnable是没有多线程的功能的，必须new
thread创建线程，然后将a的实例作为参数产给它，这样和thread合起来才实现了线程的功能。
这两种方法是面向对象的两种设计思想的体现，即继承和组合，①是继承，将thread继承过来，加上a自己的东西（run方法）构成完整的线程，②是组合，将thread和a组合起来，构成线程。面向对象的原则是：尽量用组合替代继承，所以推荐第二种方法。
