JAVA中线程的实现方式

目录

1.继承Thread类 重写run方法

源码解析：

2.实现Runnable接口 重写run方法

匿名内部类方式：

lambda方式：

3.实现Callable 重写call方法，配合FutureTask

 源码解析：

4.基于线程池构建线程

 源码解析：

结论：无论是哪种方式，从底层源码来看都是基于一种方式,实现Runnble  

---

线程的创建方式大致分为四种方式：

• 1.继承Thread类 重写run方法
• 2.实现Runnable接口 重写run方法
• 3.实现Callable 重写call方法，配合FutureTask
• 4.基于线程池构建线程

1.继承Thread类 重写run方法

启动线程是调用start方法，这样会创建一个新的线程，并执行线程的任务。

如果直接调用run方法，这样会让当前线程执行run方法中的业务逻辑。

public class MiTest {

    public static void main(String[] args) {
        MyJob t1 = new MyJob();
        t1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:" + i);
        }
    }

}
class MyJob extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyJob:" + i);
        }
    }
}

源码解析：

  

MyJob类实际上是继承于Thread类的，然后Thread类又是实现Runnable接口的，总的来说底层实际上是通过实现Runnable接口的方式来实现线程的创建的。

2.实现Runnable接口 重写run方法

public class MiTest {

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:" + i);
        }
    }

}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("MyRunnable:" + i);
        }

    }
}

匿名内部类方式：

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

lambda方式：

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 100; i++) {
        System.out.println("lambda:" + i);
    }
});

3.实现Callable 重写call方法，配合FutureTask

Callable一般用于有返回结果的非阻塞的执行方法

同步非阻塞。

public class MiTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1. 创建MyCallable
        MyCallable myCallable = new MyCallable();
        //2. 创建FutureTask，传入Callable
        FutureTask futureTask = new FutureTask(myCallable);
        //3. 创建Thread线程
        Thread t1 = new Thread(futureTask);
        //4. 启动线程
        t1.start();
        //5. 做一些操作
        //6. 要结果
        Object count = futureTask.get();
        System.out.println("总和为：" + count);
    }
}

class MyCallable implements Callable{

    @Override
    public Object call() throws Exception {
        int count = 0;
        for (int i = 0; i < 100; i++) {
            count += i;
        }
        return count;
    }
}

 源码解析：

 FutureTask实现于RunnableFuture接口，RunnableFuture接口又实现于Runnable接口，总的来说依然是通过实现Runnable接口的方式来实现线程的创建的。

4.基于线程池构建线程

public class demo{
    public static void main(String[] args) {

        //创建固定个数的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        for(int i =0;i<3;i++){
            //执行任务
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名:" +Thread.currentThread().getName());
                    //说明是使用线程池来创建线程
                }
            });
        }

    }
}

 源码解析：

 这里直接就创建Runnable对象进行线程的创建了

结论：无论是哪种方式，从底层源码来看都是基于一种方式,实现Runnble