Java创建多线程的方法

Java提供了三种创建线程的方法

• 继承Thread类
• 实现Runnable接口
• 通过Callable接口和 Future创建线程（JDK5.0新增线程创建方式）

---

方式一：通过继承Thread来创建线程

        创建一个线程只需要新建一个类并继承于Thread类，并重写Thread类中的run()方法，run()方法中实现的是子线程中具体的业务逻辑。最后在主线程中将此类实例化，再调用start()方法启动即可。

        具体步骤：

        1）新建一个类并继承于Thread类

class MyThread extends Thread{
    
    @override
    public void run(){
        //具体的业务逻辑
    }

        2）在主线程中将新建的类实例化，并调用start()方法，这样run()方法中的代码就会在子线程中运行

MyThread myThread = new MyThread();
myThread.start();

       或者直接写

 new MyThread().start();

        当然，也可以使用创建匿名类的方法。 

Thread t1 = new Thread(){

    @Override
    public void run() {
        
    }
};
t1.start();

 

方式二：通过实现 Runnable 接口来创建线程

        新建一个类实现Runnable接口，并重写接口中的run()方法。在主线程中实例化此类和Thread类，把自定义类的实例化对象放入Thread类的构造函数中，最后调用start()方法启动线程。

        具体步骤：

        1）新建一个类实现Runnable接口

class MyThread implements Runnable{
    
    @override
    public void run(){
        //具体的业务逻辑
    }

        2）在主线程中启动子线程

MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread);
t1.start();

        上面代码可以简化为

MyThread myThread = new MyThread();
new Thread(myThread).start();

        当然，这样新建类再在主线程中实例化的方法也是比较麻烦的，以下这种方法更为常见

new Thread(new Runnable(){
    
    @override
    public void run(){
        
    }
}).start();

方式三：通过 Callable 和 Future 创建线程

        具体步骤：

        1）创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

        2）创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

        3 ）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

        4）调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

public class MyCallableThread implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        MyCallableThread myCT = new MyCallableThread ();  
        FutureTask<Integer> ft = new FutureTask<>(myCT);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                //FutureTask对象作为Thread对象的target创建新的线程，并启动线程
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            //调用get()方法取得新创建的新线程中的call()方法返回的结果
            System.out.println("子线程的返回值："+ft.get()); 
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        for(int i=0;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);
        }  
        return i;  
    }  
}

        当然，还可以把线程放入线程池中，这里就不赘述了。