一个进程正在运行时，至少会有一个线程在运行。
package ChapterOne;
public class Test {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName());
//currentThread方法返回正在被执行的线程的信息
//getName返回正在被执行线程的名字
}
}执行结果：
这里输出的main其实是一个名字为mian的线程在执行main()方法中的代码，也就是说，当前线程的名字mian与mian()方法无关。该线程由JVM创建。
package ChapterOne.test1;
public class A {
public static void main(String[] args) {
B b = new B();
b.bMethod();
}
}package ChapterOne.test1;
public class B {
public void bMethod() {
System.out.println("B bMethod "+Thread.currentThread().getName());
}
}运行结果：
这里B类中的bMethod方法打印出当前执行线程的名称依旧是main，进一步说明当前线程名称为main与jmain方法无关。
Java中实现多线程编程的方式主要有两种：一种是继承Thread类，另一种是实现Runnable接口。
继承Thread类
Thread的声明：
public
class Thread implements Runnable 由此可见，Thread类实现了Runnable接口，也就是说，它们之间存在多态的关系。
package ChapterOne.myThread;
public class MyThread extends Thread{
Runnable r1 = new Thread();
Runnable r2 = new MyThread();
Thread r3 = new MyThread();
}使用Thread创建新线程时，最大的局限就是由于Java语言的单根继承特点，所以继承Thread类后就不能再继承其他类了，如果必须要继承其他类，就可以使用实现Runnable接口的方式来创建新线程。这两种方式创建线程的功能是一样的，本质上没有什么区别。
start()方法和run()方法
package ChapterOne.myThread;
public class MyThread extends Thread{
@Override
public void run(){
super.run();
System.out.println("MyThread");
}
}package ChapterOne.test;
import ChapterOne.myThread.MyThread;
public class Run {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
System.out.println("运行结束。");
}
}运行结果：
这里使用start()方法启动一个线程，线程启动后调用线程对象中的run()方法，而run()方法中的代码就是说线程对象将要执行的内容，它是线程执行任务的入口。
run()方法：这个线程要做什么，是线程执行任务的入口。
start()方法：启动线程。
从上述代码中的执行情况可以看出， System.out.println("运行结束。");耗时较小，而 myThread.start();耗时较大，原因在于：
start()方法内部执行了多个步骤
- 首先，要通过JVM告诉操作系统创建Thread。
- 然后，操作系统开品内存并通过一些步骤创建Thread线程对象。
- 之后，操作系统对Thread对象进行调度，确定其执行时机。
- 最后，Thread在操作系统中被成功调用。
而main()线程执行start()方法时，并不需要等待其执行完毕再去执行下一行代码。
在这种情况下，也有可能先输出MyThread再输出运行结束，这也就是线程执行的顺序具有随机性。
实现Runnable接口
上面我们谈到，如果想创建的线程已经有了一个父类，就不能继续继承Thread类了。这个时候我们采用实现Runnable的方式来创建线程。
Thread的构造函数
在Thread的构造函数中，有五个构造方法可以传入Runnable接口，这说明构造方法支持传入一个Runnable接口的对象。
package ChapterOne.myRunnable;
public class Run {
public static void main(String[] args) {
Runnable runnable = new myRunnable();
Thread thread = new Thread(runnable);
thread.start();
System.out.println("运行结束");
}
}package ChapterOne.myRunnable;
public class myRunnable implements Runnable{
@Override
public void run() {
System.out.println("运行中");
}
}运行结果：
执行结果依旧是异步执行。
使用Runnable接口的优点
Java是单继承，因此在要创建的线程已经继承其他父类时，不能再使用Thread类来创建线程，此时只能通过实现Runnable接口来创建线程。
package ChapterOne.myRunnable;
public class AServer {
public void a_save_method(){
System.out.println("a中的保存数据方法被执行");
}
}package ChapterOne.myRunnable;
public class BServer extends Thread,AServer{
public void b_save_method() {
System.out.println("a中的保存数据方法被执行");
}
}存在问题：
进行更改
package ChapterOne.myRunnable;
public class BServer extends AServer implements Runnable{
public void b_save_method() {
System.out.println("a中的保存数据方法被执行");
}
@Override
public void run() {
b_save_method();
}
}由于Thread也实现了Runnable接口。
所以，构造函数Thread（Runnable target）中不仅可以传入Runnable接口的对象，还可以传入一个Thread对象。
package ChapterOne.myRunnable;
import ChapterOne.myThread.MyThread;
public class Test {
public static void main(String[] args) {
MyThread thread = new MyThread();
Thread t = new Thread(thread);
t.start();
}
}MyThread是Thread的子类，而Thread是Runnable的实现类，所以MyThread也相当于是Runnable的实现类。
使用Runnable接口方式实现多线程可以把”线程“和”任务“分离。Thread代表线程，而Runnable代表可运行的任务。Runnable中包含Thread线程要执行的代码，也就是说这样可以实现多个Thread共用一个Runnable。
