线程的推进的两种方式，Runnable模块，run（）的定义转载

有两种方法可以实现和启动线程。
1，编写从继承的类。Thread类，重写run方法。用start方法启动线程。
2，编写类实现。Runnable接口、实现run方法。用new Thread(Runnable target).start()要启动的方法

多线程原理： 相当于玩游戏机，只有一台游戏机(cpu)，但是有很多人可以玩，所以，start这是一个队列！等CPU如果你被选中，轮到你了，你会run（），当CPU在执行运行时间片之后，该线程将继续排队等待下一次。run（）。

调用start（）之后，线程被放置在等待队列中等待。CPU调度不必立即启动，只需将此线程置于可移动状态。然后通过JVM，线程Thread会调用run（）方法来执行此线程的线程体。 先调用start后调用run，太麻烦了，为了不直接打电话run？ 为了实现多线程的优点，没有这样的事情。start不行。

1. start（）要启动的方法线程，真正实现了多线程运行。 此时无需等待。run方法体代码执行后，可以继续直接执行以下代码；Thread类的start()要启动的方法一个线程， 该线程处于就绪状态， 没有运行。 然后通过这个Thread类调用方法run()为了完成其操作， 这里方法run()调用包含要执行的线程内容的线程主体， Run方法运行结束， 此线程终止。然后CPU计划其他线程。
2. run（）该方法被称为普通方法。 程序仍需要按顺序执行，等待run执行方法体后，可以继续执行以下代码：； 程序中只有一个主线程，这一个线程， 仍然只有一个程序执行路径， 这不能达到编写线程的目的。

记住： 多线程是分时的。CPU，宏让所有线程一起执行。 ，也称为并发

1 public class Test {
2 public static void main(String[] args) {
3 Runner1 runner1 = new Runner1();
4 Runner2 runner2 = new Runner2();
5 // Thread(Runnable target) 分配新的 Thread 对象。
6 Thread thread1 = new Thread(runner1);
7 Thread thread2 = new Thread(runner2);
8 // thread1.start();
9 // thread2.start();
10 thread1.run();
11 thread2.run();
12 }
13 }
14
15 class Runner1 implements Runnable { // 实现了Runnable接口，jdk我知道这门课是一条线。
16 public void run() {
17 for (int i = 0; i < 100; i++) {
18 System.out.println("进入Runner1运行状态----------" + i);
19 }
20 }
21 }
22
23 class Runner2 implements Runnable { // 实现了Runnable接口，jdk我知道这门课是一条线。
24 public void run() {
25 for (int i = 0; i < 100; i++) {
26 System.out.println("进入Runner2运行状态==========" + i);
27 }
28 }
29 }

上述安排来自：http://blog.csdn.net/xuxurui007/article/details/7685076

【线程的 创建和启动步骤 （ 实现Runnable接口方式 ）】

1. 定义Runnable接口和重写的实现类run方法。 run()方法的方法体 是 线程执行器 。

class SonThread  implement Runnable{

public void run(){

......

}

}

2. 创建Runnable接口实现类的实例。                        sonThread s1=new SonThread();

3. 使用此实例Thread的target来创建Thread对象。   Thread t1 =new Thread(s1);

4. 调用对象的start()方法启动线程。。                       t1.start();

[注1：关于命名]]

在创建Thread 该对象可以用于Thread对象指定了一个名称。

【注2：Thread施工方法]

Runnable对象作为Thread对象的target，Runnable实现类包含run方法仅作为执行器。也就是说Thread班级的角色是run该方法被包装为线程的执行。

实际运行的线程对象是静止的。Thread实例，仅此而已。Thread线程负责执行target的run方法。

1 //1.1定义Runnable接口的实现类。 2 class SecondThread implements Runnable{ 3 4 //1.2重写run方法 5 @Override 6 public void run() { 7 for(int i=0;i<10;i++){ 8 System.out.println(Thread.currentThread().getName()+"===="+i); 9 } 10 } 11
12 } 13 public class Demo2 { 14
15 public static void main(String[] args) { 16 //2.创建Runnable接口实现类的实例。 17 SecondThread s1=new SecondThread(); 18 SecondThread s2=new SecondThread(); 19 //2.用Runnable接口实现类的实例。作为Thread的target，创建Thread对象 20 Thread t1=new Thread(s1); 21 Thread t2=new Thread(s2,"Higgin"); //创建Thread可以同时命名对象。 22
23 //启动线程 24 t1.start(); 25 t2.start(); 26
27 for(int i=0;i<10;i++){ 28 System.out.println(Thread.currentThread().getName()+"===="+i); 29 } 30 } 31 }

上述安排来自：http://www.cnblogs.com/HigginCui/p/5901593.html

通过JDK源码解析Thread(Runable target ...)哪个叫run方法

代码1：

1 new Thread(new Runnable() {
2 @Override
3 public void run() {
4 System.out.println("Run of Runnable");
5 }
6 }) {
7 public void run() {
8 System.out.println("Run of Thread");
9 }
10 }.start();

代码2：

1 new Thread(new Runnable() {
2 @Override
3 public void run() {
4 System.out.println("Run of Runnable");
5 }
6 }) {
7 public void run() {
8 System.out.println("Run of Thread");
9 super.run();
10 }
11 }.start();

首先，让我们来看看JDK的Thread源代码，片段 3 如下：

1 private Runnable target;

public void run() {
if (target != null) {
target.run();
}
}

在run()方法，首次检查target为空，否则执行target的run()方法。

那么，对于上述两段代码的执行，就很清楚了。

在第一个片段中 1 在中，重写Thread的run()方法，同时传入Runnable对象，它还实现run()方法。该Thread对象调用start()方法，则重写该对象。run()方法，其输出也是Run of Thread在输出之后，run()方法返回，线程对象的生命周期结束。

在第二个片段中 2 ，它也被重写。Thread的run()方法，同时传入Runnable对象，实现run()方法唯一的区别是Thread重写的run方法，在打印输出后，也执行super.run()这很有趣。

首先，在线程开始运行后，它执行重写。run()方法，输出Run of Thread。

下一次呼叫super.run()，即调用超类run()方法和超类的run()方法，即JDK定义的Thread类的run()，其执行与上述片段中的相同。 3 展示；显然地target不为空，这时候会调用对象的run()方法，将输出Run of Runnable.。

如果，上述Thread并未重写run()方法，则执行的结果仍然相同。这将首先执行。Thread的run()方法，因为该方法此时未被重写，所以它仍被调用。JDK定以的run()方法，即上面的代码段 3，将在此片段中进行判断。target它是否为空，显然不是，因此将被调用。Runnable对象已实现run()方法。

摘要：Thread(Runnable target ...)，无论传入Target无论它是否为空，都将首先执行。Thread自己的run()方法如果方法被重写并且没有super.run()，则从不调用。Runnable实现的run()方法如果该方法未被重写，则进行判断。target是否为空以确定调用。target实现的run()方法如果该方法被重写，并且该方法具有super.run()，在执行语句之前的所有代码后，将对其进行判断。target是否为空以确定调用。target实现的run()方法，然后在语句之后执行代码。

上述安排来自：http://blog.csdn.net/guguituzi/article/details/44593863