Java创建多线程的两种方法的详细步骤介绍

1.方式一:继承Thread类创建多线程的多种写法

①写法一

1.创建一个继承Thread类的子类
2.重写Thread类的run( )方法
3.在run( )方法中写上你想让该线程执行的操作
4.创建Thread类的子类的对象
5.通过此类对象调用start( )方法。

//方式一
// 1.创建一个继承与Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()
    @Override
    public void run() {
    	//3.在run( )方法中写上你想让该线程执行的操作，此处写的是输出100以内的偶数
        for (int i = 2; i <= 100; i++) {
            if (i % 2 == 0) {        
                  System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //4.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //5.通过此类对象调用start()
        t1.start();
    }
}

②写法二

1.创建一个继承Thread类的子类
2.重写Thread类的run( )方法
3.在run( )方法中写上你想让该线程执行的操作
4.创建匿名对象调用start( )方法

//方式二
// 1.创建一个继承与Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()
    @Override
    public void run() {
    	//3.在run( )方法中写上你想让该线程执行的操作，此处写的是输出100以内的偶数
        for (int i = 2; i <= 100; i++) {
            if (i % 2 == 0) {        
                  System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //4.创建匿名对象调用start( )方法
        new MyThread().start();
    }
}

③写法三

1.创建Thread类的匿名子类

//方式三：创建Thread类的匿名子类
public class ThreadTest{
    public static void main(String[] args) {
    	//1.创建一个Thread
        new Thread(){
        	//2.在花括号内直接重写Thread的run方法
            @Override
            public void run() {
                for(int i = 2;i <= 100;i += 2){
                    System.out.println(i);
                }
            }
        }.start();//调用start()
    }
}

2.方式二:实现Runnable接口

1.创建一个实现了Runnable接口的类
2.通过该类去实现Runnable中的抽象方法run()
3.在run( )方法中写上你想让该线程执行的操作
4.创建实现类的对象
5.将此对象作为参数传递到Thread类的构造器中，创建Tread类的对象
6.通过Thread类的对象调用start()方法

//1.创建一个实现了Runnable接口的类
class MyThread implements Runnable{

    //2..通过该类去实现Runnable中的抽象方法run()
    @Override
    public void run() {
    	//3.在run( )方法中写上你想让该线程执行的操作
        for(int i = 2;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        // 4.创建实现类的对象
        MyThread myThread = new MyThread();
        // 5.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myThread);
        // 6.通过Thread类的对象调用start()
        t1.start();
    }
}

3.Thread和Runnable两种创建线程方式的比较

①开发中应该选择哪种创建线程的方式

在开发中优先选择通过实现Runnable接口的方式来创建线程。
原因：
①实现Runnable接口的方式没有类的单继承性的局限性。而通过继承Thread类来创建线程后无法再继承其他类，有局限性。
②实现Runnable接口的方式更适合用来处理多个线程之间数据共享的情况。

②Thread和Runnable两者之间的关系

Thread类实现了Runnable接口。

//Thread类的声明
public class Thread implements Runnable

③Thread和Runnable两者的共同点

两种创建线程的方式都需要重写run()方法，将线程要执行的代码声明在run()中。

叫法上的细微区别

通过Thread创建线程一般叫重写run()方法。
通过Runnable创建线程一般叫实现run()方法，因为Runnable是接口。