多线程的三种创建方式详解

多线程

 

方式一

/**
 * 目标：多线程的创建方式一：继承thread类实现。
 */
public class ThreadDome1 {
    public static void main(String[] args) {
        //3.new 一个线程对象
        Thread t=new MyThread();
        //调用start方法启动线程（执行的还是run方法）
        t.start();
​
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行"+i+"次");
        }
​
    }
}
​
/**
 * 1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
     * 2.重写run方法，里面是定义线程以后干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行"+i+"次");
        }
    }
}

方式二

/**
 *目标：学会线程的创建方式二，理解他的优缺点。
 */
public class ThreadDome2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable t=new MyRunnable();
        new Thread(t).start();
​
        for (int i = 0; i < 10; i++) {
            System.out.println("11111111111111"+i);
        }
    }
}
​
/**
 * 1.定义一个线程任务类，实现runnable接口
 */
​
class MyRunnable implements Runnable{
    /**
     * 2.重写run方法，定义线程的执行任务
     */
​
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行"+i);
        }
    }
}

方式二（匿名内部类）

​
/**
 *目标：学会线程的创建方式二(匿名内部类方式实现，语法形式)
 */
public class ThreadDome2Other {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable t=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("1");
                }
            }
        };
        new Thread(t).start();
​
​
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("2");
                }
            }
        }).start();
​
        new Thread(()-> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("3");
                }
        }).start();
​
​
        for (int i = 0; i < 10; i++) {
            System.out.println("4");
        }
    }
}

方式三

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
​
/**
 目标 ：学会线程的创建方式三，实现Callable接口，结合FutureTask完成
 */
public class ThreadDome3 {
    public static void main(String[] args) {
        //3.创建Callable的任务对象
        Callable<String> call=new MyCallable(100);
        //4.把Callable任务对象 交给FutureTask对象
        //FutureTask对象的作1： 是Runnable的对象（实现类Runnable接口），可以交给Thread
        //FutureTask对象的作用2：可以在线程执行完毕之后通过调用其get方法得到线程结果
        FutureTask<String> f1=new FutureTask<>(call);
        //5.交给线程处理
        Thread th=new Thread(f1);
        //6.启动线程
        th.start();
​
        Callable<String> call2=new MyCallable(200);
        FutureTask<String> f2=new FutureTask<>(call2);
        Thread t2=new Thread(f2);
​
        t2.start();
​
        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String s = f1.get();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
​
        try {
            //如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String s = f2.get();
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
​
/**
 * 定义一个任务类 实现Callable 应该声明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
​
    /**
     * 重写call方法 （线程的任务方法）
     */
    @Override
    public String call() throws Exception {
       int sum=0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return "子线程执行的结果是"+sum;
    }
}