如何使用多线程

一个进程正在运行时，至少会有一个线程在运行。

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。