(JAVA)-创建多线程的方式

1.继承Thread类

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

2.重写Thread类的run方法

public class MyThread extends Thread{
    @Override
    public 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{
    @Override
    public 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> {
    @Override
    public 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());
    }
}