Question

java 中Thread 和Runnable有何区别？

这有两例子，run()的内容一样，但是结果不一。
实现Runnable 接口 为我想要的结果，先执行完一个线程再执行另外一个。
继承Thread类 为交叉执行，貌似synchronized(this) 形同虚设
请问这是为什么？
1.
public class synchronize2 extends Thread{
public void run(){
synchronized(this){
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+" synchronizedloop "+i);
}
}

}
public static void main(String args[])
{
synchronize2 s1=new synchronize2();
synchronize2 s2=new synchronize2();
s1.start();
s2.start();
}
}

2.
public class synchronize1 implements Runnable {
public void run() {
synchronized(this)
{
for(int i=0;i<5;i++)
{
System.out.println(Thread.currentThread().getName()
+" synchronizedloop "+i);
}

}

}
public static void main(String args[])
{
synchronize1 t1=new synchronize1();
Thread ta=new Thread(t1,"A");
Thread tb=new Thread(t1,"B");
ta.start();
tb.start();
}

}

Answer 1

区别：Thread是类，而Runnable是接口。
抽象类和接口的区别如下：
① 在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现接口则要实现里面的全部方法。
②在接口中无成员变量，而抽象类中可有成员变量。
在Java中引进接口主要是为了解决多继承的问题。
实现多线程主要继承Thread 类和实现Runnable接口。

Answer 2

我尽最大努力把问题解释清楚，不足之处，请赐教！
首先，
之所以出现线程，就是为了更好的利用CPU，让她更加“精明”的干活。

通过调用Thread类的start()方法来启动一个线程，
这时此线程是处于就绪状态，
并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，
这里方法run()称为线程体，
它包含了要执行的这个线程的内容，
Run方法运行结束，
此线程终止，
而CPU再运行其它线程，

而如果直接用Run方法，
这只是调用一个方法而已，
程序中依然只有主线程--这一个线程，
其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

记住：线程就是为了更好地利用CPU，
提高程序运行速率的！

public class TestThread1{
public static void main(String[] args){
Runner1 r=new Runner1();
//r.run();//这是方法调用，而不是开启一个线程
Thread t=new Thread(r);//调用了Thread(Runnable target)方法。且父类对象变量指向子类对象。
t.start();

for(int i=0;i<100;i++){
System.out.println("进入Main Thread运行状态");
System.out.println(i);
}
}
}
class Runner1 implements Runnable{ //实现了这个接口，jdk就知道这个类是一个线程
public void run(){

for(int i=0;i<100;i++){
System.out.println("进入Runner1运行状态");
System.out.println(i);
}
}
}

如果还看不明白的话，
我QQ：516258551
咱们再在QQ上讨论

不知答案能否让你满意

Answer 3

thread是类,runnable是接口,都可以是多线程,

但是在创建多线程的方法中我们可以有2种方法

class MyThread extends Thread{
public void run(){
System.out.println("this is thread");
}
}

class MyRunnable implements Runnable{
    public void run(){
        System.out.println("this is runnable");
    }
}

在实际使用中我们推荐使用runnable方法

因为如果使用thread的话就不能继承其他类(ps:一个类只能继承一个父类)

但是runnable就不同(一个类可以实现多个接口)

以上是我的理解

Answer 4

你使用Runnable接口创建的接口使用同一个对象t1，t1中的synchronized(this)把当前活动的线程加上了互斥锁，所以实现了Runnable接口的线程不是交叉的。
而使用Thread创建了两个线程，而这两个线程中synchronized(this)的this并不指向同一对象，所以会交叉执行。

Answer 5

synchronized(this)锁的只是你new 出来的s1、s2这两个对象，并不是锁定synchronize1 这个类

下面那种情况锁定的是t1