线程的三种创建方式

线程的创建方式

1、继承Thread类

public class ThreadDemo extends Thread{
	
    // 重写run()方法
    @Override
    public void run() {
        System.out.println("4567890-987e456789");
    }
}

创建线程对象并调用

 public static void main(String args[]) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
    }

这样虽然可以创建一个线程，但是这种方式有个局限性，就是单继承局限性，一旦继承了Thread类，就不能继承其他类了。

2、实现Runnable接口

/**
 * 通过实现 Runnable 接口创建线程
 */
public class DisplayMessage implements Runnable {

    private Integer source = 3;

    public void run() {
        saveMethod();
    }

    public void saveMethod() {
        System.out.println(Thread.currentThread().getName()+"消耗了资源：" + (source--));
    }

}

定义一个线程对象和多个Thread对象：

public static void main(String[] args) {
    Runnable hello = new DisplayMessage();

    Thread thread1 = new Thread(hello);
    Thread thread2 = new Thread(hello);
    Thread thread3 = new Thread(hello);

    thread1.start();
    thread2.start();
    thread3.start();
}

可以看出一个Runnbale接口对象可以被多个线程同时使用。

总结一下，进行多线程编程的两种方式：

1、继承Thread类

　　　　定义一个类，继承Thread类，重写run方法，run方法包含了线程执行的任务；

　　　　创建这个类对象，然后通过对象调用start方法启动线程，直接执行的就是子类中重写的run方法。

　　　　这种方式有个局限性，就是单继承局限性，一旦继承了Thread类，就不能继承其他类了。

2、实现Runnable接口

　　　　定义一个类，实现Runnable接口，重写run方法，run方法包含了线程执行的任务；
　　　　
　　　　创建这个类对象，然后再创建相应数量的Thread对象，作为代理，将Runnable接口对象传入Thread对象中，然后调用Thread对象的start方法启动线程。启动的过程就是先初始化线程对象将传入的Runable接口对象赋予target成员变量，然后执行run方法调用Runnable接口对象的run方法。

简单分析一下源码：

其实Thread类也是实现了Runnable接口的类：

public
class Thread implements Runnable {
        ……
}

在创建Thread对象的时候，会判断，如果调用里面传Runnable的参数，就会执行里面的this.target = target;，JVM会执行Thread类的run方法，也就是上面源码显示的，先对成员变量target进行判空，如果对象不是null，就执行target的run方法，这个run方法也就是我们自定义的实现Runnable接口的类中实现的run方法。

3、通过Callable和Future创建线程

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for(int i = 0;i < 10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==5)
            {
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }

    }
    @Override
    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }
}

运行结果如图：