多线程入门

目录

什么是多线程

实现多线程的三种方式

---

什么是多线程

同一时间做多件事情，我们把他叫做多线程，比如一个时间段内，我们可以一边走路，一边听音乐

实现多线程的三种方式

继承thread类,需要重写run方法

public class ThreadClass_01 extends Thread{

    @Override
    public void run() {
        System.out.println("thread_01 run");
    }
}

public class ThreadClass_02 extends Thread{

    @Override
    public void run() {
        System.out.println("thread_02 run");
    }
}

public class ThreadTest {

    /**
     * 继承Thread 类
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("------开始运行--------");

        ThreadClass_01 threadClass_01 = new ThreadClass_01();
        ThreadClass_02 threadClass_02 = new ThreadClass_02();
        threadClass_01.start();
        threadClass_02.start();
        System.out.println("--------结束运行----------");
    }
}

实现runnable接口，需要重写run方法

public class ThreadRunnable_01 implements Runnable{
    @Override
    public void run() {
        System.out.println("runabble class 01");
    }
}

public class ThreadRunnable_02 implements Runnable{
    @Override
    public void run() {
        System.out.println("runabble class 02");
    }
}

public class RunnableThreadTest {

    /**
     * 继承Thread 类
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("------开始运行--------");

        ThreadRunnable_01 threadClass_01 = new ThreadRunnable_01();
        ThreadRunnable_02 threadClass_02 = new ThreadRunnable_02();
        new Thread(threadClass_01).start();
        new Thread(threadClass_02).start();
        System.out.println("--------结束运行----------");
    }
}

实现callable接口，callable是有返回的多线程实现方式，callable<T> 范型是什么类型就返回什么类型的数据

public class ThreadCallable_02 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName() + "class 02";
    }
}

public class ThreadCallable_01 implements Callable<String> {

    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName() + "class 01";
    }
}

public class CallableTest {

    /**
     * 继承Thread 类
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("------开始运行--------");

        FutureTask<String> callAble1 = new FutureTask<>(new ThreadCallable_01());
        FutureTask<String> callAble2 = new FutureTask<>(new ThreadCallable_02());

        new Thread(callAble1).start();
        new Thread(callAble2).start();
        System.out.println(callAble1.get());
        System.out.println(callAble2.get());

        System.out.println("--------结束运行----------");
    }
}

这里使用Thread是因为FutureTask也实现了RunnableFuture 并且 RunnableFuture继承了 runnable