1.继承Thread类

1.创建一个继承字Thread类的子类

2.重写Thread类的run方法

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName()+"hello");}}
}

3.创建Thread类的子类对象

4.通过子类对象调用start方法

public class test {public static void main(String[] args) {MyThread t1=new MyThread();MyThread t2=new MyThread();t1.setName("线程1");//给线程对象取名t2.setName("线程2");t1.start();t2.start();}
}

strat方法：启动当前线程，然后由jvm去调用该线程的run方法

run:仅仅是被封装被线程执行的代码，直接调用是普通方法，不会启动线程

可以看到程序一会执行线程1，一会执行线程2

2.实现runnable接口

1.创建一个实现Runnable接口的类

2.实现类去实现Runnable接口中的run抽象方法

public class MyRun implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {Thread t=Thread.currentThread();//获取当前线程对象System.out.println(t.getName()+"helloword");}}
}

3.创建实现类对象

4.创建Thread对象，并将实现类对象传入Thread类的构造器中

5.通过Thread类的对象调用start方法

    public static void main(String[] args) {
MyRun mr=new MyRun();//创建多线程要执行的任务Thread t1=new Thread(mr);Thread t2=new Thread(mr);t1.start();t2.start();}
}

注意：一般使用的是实现Runnabble接口方式，因为java只能单继承但能实现多接口

3.callable接口和future接口方式实现

前两种方法的run方法都没有返回值，而第三种方法解决了这个弊端

1.创建一个实现类（Mycallable）实现Callable接口

2.重写call方法

public class MyCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i < 100; i++) {sum=sum+i;}return sum;}
}

3.创建实现类（MyCallable）对象

4.创建Future实现类（FutureTask)对象，将MyCallable对象参数传入

5.创建Thread对象，并将Future实现类对象传入Thread类的构造器中

6.通过Thread类的对象调用start方法

       MyCallable mc=new MyCallable();//表示多线程要执行的任务FutureTask<Integer> ft=new FutureTask<>(mc);//管理多线程运行的结果Thread t=new Thread(ft);t.start();System.out.println(ft.get());}
}