java创建线程任务，Thread基本方法

3种创建方式

1.创建任务类继承Thread，start
2.创建任务类实现Runnable接口，交给Thread，start。比起1的好处在于还可集成其他类
2.1 匿名内部类
2.2 lambda表达式创建
3. 实现Callable接口，封装成FutureTask对象，再交给Thread。比起2好处在于：可以掉get方法拿到线程返回结果

MyThread

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("任务对象run"+i);
        }
    }
}

MyRunnable

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("Runnable对象："+i);
        }
    }
}

MyCallable

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        //描述线程任务，返回执行结果
        int sum=0;
        for(int i=1;i<=n;i++){
            System.out.println("子线程："+i);
            sum+=i;
        }
        return "线程求出了1-"+n+"的和是："+sum;
    }
}

Test

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1.创建任务类，继承Thread
        Thread sub1 = new MyThread(); //
        sub1.start();

        //2.创建任务类，实现Runnable接口，重写run方法，再交给Thread
        Thread sub2 = new Thread(new MyRunnable());
        sub2.start();

        //2.1 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("匿名内部类"+i);
                }
            }
        }).start();

        //2.2 lambda创建
        new Thread(()-> {
            for(int i=0;i<10;i++){
                System.out.println("lambda创建"+i);
            }
        }).start();


        //3.callable创建

        //创建callable对象
        Callable<String> call = new MyCallable(10);

        //封装成FutureTask对象，实现了runnable接口，是一个任务对象，可以交给线程对象；可以再线程执行完毕后，用未来任务对象的get方法获取执行结果
        FutureTask<String> f1 = new FutureTask<>(call);

        //线程执行
        new Thread(f1).start();


        //主线程
        for(int i=0;i<10;i++){
            System.out.println("主线程："+i);
        }

        //获取线程执行后的结果
        String res = f1.get(); //这里的代码会暂停，等待上面线程执行完毕
        System.out.println(res);

    }
}

Thread基本方法

静态方法currentThread被哪个线程执行，就可以拿到该线程对象