java创建线程的方式

Java创建线程的四种方式：

1.继承Thread类覆写run()方法实现多线程
2.实现Runnable()接口实现多线程，而后同样覆写run()方法
3.实现Callable接口覆写call()方法实现多线程
4.通过线程池启动多线程

1.继承Thread类实现多线程
• 创建线程的步骤：
• 定义一个类继承Thread。
• 重写run()方法。
• 创建子类对象，就是创建线程对象。
• 调用start()方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

class Dem1 extends Thread{//继承Thread类
        private  String name;
        Dem1(String name){
            this.name=name;
        }

    @Override
    public void run() {//重写run方法
        for (int i=0;i<3;i++){
            //Thread.currentThread().getName() 获得当前线程对象 名称
            System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
        }
    }
}


public class ThreadDem1 {
    public static void main(String[] args) {
        Dem1 d1=new Dem1("张三");//创建对象
        Dem1 d2=new Dem1("李四");//创建对象
        d1.run(); //对象直接执行run方法
        d1.start();//start方法开启线程执行run方法
        d2.start();//start方法开启线程执行run方法
       
    }
}

2.实现Runnable接口

• 定义类实现Runnable接口。
• 覆盖接口中的run方法。 创建Thread类的对象。
• 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
• 调用Thread类的start方法开启线程。

public class TreadDem2 {
    public static void main(String[] args) {
        Dem3 d1=new Dem3();//创建对象
        Dem3 d2=new Dem3();//创建对象
        Thread t1=new Thread(d1);//类对象作为参数传递给Thread类的构造函数
        Thread t2=new Thread(d2);//类对象作为参数传递给Thread类的构造函数
        t1.start();//开启线程
        t2.start();//开启线程
    }
}


class Dem3 implements Runnable{//实现 Runable接口
    private String name;

    @Override
    public void run() {//覆写run方法
        for (int i=0;i<10;i++){
            System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
        }
    }
}

3.实现Callable接口
Callable接口是Java5新增的接口，它不是Runnable接口的子接口，所以就不能作为Thread的target。但call()方法还有一个返回值，如何获取这个返回值呢？Java5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，同时也实现了Runnable接口（可以作为Thread类的target了）
Future 接口定义了如下几个公共方法来控制它关联的Callable任务：
（1）boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future里关联的Callable任务。
（2）V get()：返回Callable任务里call()方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。
（3）V get(long timeout,TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间。如果经过指定时间Callable任务依然没有返回值，将会抛出TimeoutException异常。
（4）boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。
（5）boolean isDone()：如果Callable任务完成，返回true。

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

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
                sum += i;
        }
        return sum;
    }
}


public class ThreadDemo4 {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t=new Thread(futureTask);
        t.start();

        try {
            //6.获取Callable中call方法的返回值(如果对call方法的返回值不感兴趣，就不需要调用futureTask.get()方法)
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}