Java多线程实现的几种方式

Java多线程实现的几种方式

1.继承thread类

2.实现Runnable接口

3.通过Callable和FutureTask创建线程

4.使用线程池方式—Callable接口

5.使用线程池方式--Runnable接口

 

1.继承thread类

继承thread类，重写run()方法，start()启动线程

public class TestThread extends  Thread{
    //创建线程的方式1：继承thread类，重写run方法，start()启动线程
    @Override
    public void run() {  //run方法线程体
        for(int i=0;i<200;i++){
            System.out.println("run方法线程体"+i);
        }
    }

    public static void main(String[] args) {//主线程
        //创建一个线程对象
        TestThread t=new TestThread();
        //调用start()方法开启线程，从结果看开启之后，不一定立即启动，由CPU随机调度
        t.start();

        for (int i = 0; i <1000 ; i++) {
            System.out.println("main方法线程体"+i);
        }
    }
}

2.实现Runnable接口

实现Runnable接口，并覆盖run方法，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数，start()启动线程

public class TestThread1 implements Runnable{
    //创建线程的方式2：实现Runnable接口，并覆盖run方法，
    // 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。start()启动线程
    public void run() {  //run方法线程体
        for(int i=0;i<200;i++){
            System.out.println("run方法线程体"+i);
        }
    }

    public static void main(String[] args) {//主线程
        //创建runnable接口的实例对象
        TestThread1 t=new TestThread1();
        //创建一个线程对象，通过线程对象开启线程对象
        Thread thread=new Thread(t);
        thread.start();

        for (int i = 0; i <1000 ; i++) {
            System.out.println("main方法线程体"+i);
        }
    }
}

3.通过Callable和FutureTask创建线程

1.创建Callable接口的实现类，并实现call()方法
2.创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象
3.使用FutureTask对象作为Thread对象启动新线程
4.调用FutureTask对象的get（）方法获取子线程执行结束后的返回值

与实现runnable接口不同点：
  Callable在任务结束后，可以提供返回值；
  Callable中的call()可以抛出异常，run()就不行；
  运行Callable可以拿到Future对象，该对象表示异步计算的结果，提供检查是否完成方法。

import java.util.concurrent.*;

public class TestThread2 implements Callable<Object> {
    //创建线程的方式3：通过Callable和FutureTask创建线程
    //①、创建Callable接口的实现类，并实现call()方法，改方法将作为线程执行体，且具有返回值。
    //②、创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值
    //③、使用FutureTask对象作为Thread对象启动新线程。
    //④、调用FutureTask对象的get（）方法获取子线程执行结束后的返回值。
    //与实现runnable接口不同点：
    // 1.Callable在任务结束后，可以提供返回值；
    // 2.Callable中的call()可以抛出异常，run()就不行；
    // 3.运行Callable可以拿到Future对象，该对象表示异步计算的结果，提供检查是否完成方法。

    @Override
    public Object call()  throws Exception{
        int i=0;
        for(;i<200;i++){
            String name=Thread.currentThread().getName();
            System.out.println(name+"的变量值为"+i);
        }
        return i;
    }


    public static void main(String[] args) {

        //创建Callable实现类的实例
        TestThread2 thread=new TestThread2();
        //使用FutrueTask类进行包装Callable对象
        FutureTask future=new FutureTask(thread);
       
        try {
            //使用FutureTask对象作为Thread对象启动新线程。
            Thread t=new Thread(future);
            t.start();
            Object o = future.get(); //获取返回结果
            System.out.println(o.toString());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

4.使用线程池方式—Callable接口

1. 创建Callable接口的实现类，并实现call()方法
2. 创建线程池对象
3. 创建Callable接口子类对象
4. 提交Callable接口子类对象

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

public class TestThread3 implements Callable {
    // 创建线程的方式4：使用线程池方式—Callable接口
    // 使用线程池中线程对象的步骤：
    // 创建线程池对象
    // 创建Callable接口子类对象
    // 提交Callable接口子类对象
    // 关闭线程池
    @Override
    public Object call() throws Exception {
        int i=0;
        for (; i <200 ; i++) {
            String name=Thread.currentThread().getName();
            System.out.println(name+"的变量值为"+i);
        }
        return i;
    }

    public static void main(String[] args) {
        //创建线程池对象，包含2个线程对象
        ExecutorService service=Executors.newFixedThreadPool(2);//ExecutorService：线程池类
        //创建Callable对象
        TestThread3 thread=new TestThread3();
        try{
            //从线程池中获取线程对象
            Future<Object> future=service.submit(thread);//submit获取线程池中的某一个
            //线程对象，并执行线程中的call()方法
            //submit方法执行结束后，将使用完的线程又归还到了线程池中，线程的关闭由线程池控制。
            System.out.println(future.get());
        }catch (Exception e){
            e.printStackTrace();
        }
        //关闭线程池
        service.shutdown();
    }
}

5.使用线程池方式--Runnable接口

1. 创建Runnable接口的实现类，并重写run()方法
2. 创建线程池对象
3. 创建Runnable接口子类对象
4. 提交Runnable接口子类对象

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class TestThread4 implements  Runnable{
       // 创建线程的方式4： 使用线程池方式--Runnable接口
       // 使用线程池中线程对象的步骤：
       // 创建线程池对象
       // 创建Runnable接口子类对象
       // 提交Runnable接口子类对象
       // 关闭线程池
   
       @Override
       public void run() {
           for (int i=0; i <200 ; i++) {
               String name=Thread.currentThread().getName();
               System.out.println(name+"的变量值为"+i);
           }
       }
   
       public static void main(String[] args) {
           //创建线程池对象，包含2个线程对象
           ExecutorService service=Executors.newFixedThreadPool(2);
           //创建Callable对象
           TestThread4 thread=new TestThread4();
           //自己创建线程对象的方式
           Thread t = new Thread(thread);
           t.start();
           //从线程池中获取线程对象,然后调用TestThread4中的run()
           service.submit(thread);
           //关闭线程池
           service.shutdown();
       }
   
   
   }