java多线程实现的四种方式

java多线程实现的四种方式

创建线程方式一：继承Thread类，重写run方法，调用start开启线程

//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
public class TextThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main 主线程

        //创建一个线程对象
        TextThread1 textThread1 = new TextThread1();
        //调用start方法
        textThread1.start();



        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

运行结果：
*这里会发现我们两条线程交替执行

创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口，调用start方法

//创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口，调用start方法
public class TextThread2 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TextThread2 textThread2 = new TextThread2();

        //调用线程对象，通过线程对象来开启我们的线程。代理
        new Thread(textThread2).start();



        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

效果：

创建线程方式三：实现callable接口

1.实现callable接口，重写call()方法
2.创建FutureTask实例，创建子线程实例
3.创建Thread实例，执行FutureTask
4.在主线程打印信息
5.获取打印的子线程执行结果

*对比之前两种方法1.无法获取子线程的返回值2.run方法不可以抛出异常

import java.util.concurrent.*;

//创建线程方式三：实现callable接口
//创建FutureTask实例，创建子线程实例
//创建Thread实例，执行FutureTask
//在主线程打印信息
//获取打印的子线程执行结果

//之前两种方法
//1.无法获取子线程的返回值
//2.run方法不可以抛出异常

public class TextThread4  implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行第"+i+"次");
        }
        return "子线程执行完毕";
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建FutureTask实例，创建子线程实例
        TextThread4 textThread4 = new TextThread4();
        FutureTask<String> task=new FutureTask<String>(textThread4);

        //创建Thread实例，执行FutureTask
        Thread thread=new Thread(task,"myCallable");
        thread.start();

        //在主线程打印信息
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程执行第"+i+"次");
        }

        //获取打印的子线程执行结果
        String result=task.get();
        System.out.println(result);
    }


}

效果：

创建线程方式四：使用线程池创建线程

为什么要使用线程池：
如果在真实系统里面，可能会由于业务情况，开启了很多线程，当线程数量多大时，会耗尽cpu和内存资源。
比如说，创建和销毁线程也需要时间，如果创建和销毁的时间远大于线程执行的时间，反而得不偿失。其次线程也需要占用内存空间，大量的线程会抢占宝贵的内存资源，且大量的线程回收也会给GC带来很大的压力，延长GC的停顿时间。
因此，为了避免频繁的创建和销毁线程，让创建的线程进行复用，就有了线程池的概念。
线程池里会维护一部分活跃线程，如果有需要，就去线程池里取线程使用，用完即归还到线程池里，免去了创建和销毁线程的开销，且线程池也会线程的数量有一定的限制。

测试代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//使用线程池创建线程
public class TextThread6  {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service=Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭服务
        service.shutdown();
    }
}

//通过实现runnable创建线程
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("子线程");
    }
}

效果：