JAVA基础 day13 多线程

news2024/10/16 9:43:41

一、多线程

1.1多线程的创建方法？

1.1.1方式一：继承Thread类

//创建线程的方式之一：继承Thread类
public class demo1 {
    //main方法本身是由一条主线程推进，这里创建了myThread后，已经是多线程了
    public static void main(String[] args) {
        //3.创建一个线程对象，他才是真正代表一个线程
        MyThread myThread = new MyThread();
        //4.调用start方法，启动该线程
        myThread.start();

        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + "主线程"+i);
        }


    }
}
//1.定义一个子类来继承thread类，就可以成为一个线程
class MyThread extends Thread{
    //2.重写继承自thread的run方法，run方法是你要使用该线程完成的功能
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + "子线程" + i);
            System.out.println("\n");
        }
    }

}

注意事项

主线程若放在启动子线程之前，是会先跑完主线程任务，再启动子线程，相当于没有实现多线程。

1.1.2 方式二：实现Runnable接口

//创建线程的第二种方法
public class BuildMethod_2 {
    public static void main(String[] args) {
        //3.创建线程任务类对象，代表线程任务
        myThread_Build r = new myThread_Build();
        //4.把线程任务对象，交给一个线程对象处理
        Thread t = new Thread(r);
        //5.启动线程
        t.start();

        for(int i = 0; i < 10; i++){
            System.out.println("主线程" + i);
        }
    }
}
//1.定义一个类，来实现runnable接口
class myThread_Build implements Runnable {
    //2.重写run方法，创建线程任务
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程" + i);
        }
    }
}

匿名内部类写法：

//使用runnable接口的匿名内部类 + lambda 来简化线程创建
public class Runable_lmbda {
    public static void main(String[] args) {
        new Thread(()-> {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程" + ":" + i)
                }
            }).start();
    }
}

1.1.3 方式三：实现Callable接口

前两种方式都有一个问题：重写后的run方法，无法返回直接返回结果

由此引出第三种方式：实现callable接口+FutureTask类，可以返回线程执行完后的结果

//实现callable + futureTask类创建线程
public class Method3_Callable {
    public static void main(String[] args) {
        //3.创建一个实现类对象，来代表线程任务
        Callable my_call = new MyCallable(200);
        //4.把callable的任务对象，包装成FutureTask对象
        FutureTask<String> my_future = new FutureTask<String>(my_call);
        /*
        未来任务对象的作用：
        a.本质是一个runnable线程任务对象，可以交给thread线程任务对象处理
        b.可以获取线程运行后的结果
         */
        //5.把FutureTask对象作为参数，传给thread线程对象
        Thread my_thread = new Thread(my_future);
        //6.使用线程的start方法，启动线程
        my_thread.start();

        //3.创建一个实现类对象，来代表线程任务
        Callable my_call2 = new MyCallable(100);
        //4.把callable的任务对象，包装成FutureTask对象
        FutureTask<String> my_future2 = new FutureTask<String>(my_call2);
        Thread my_thread2 = new Thread(my_future2);
        my_thread2.start();

        //获取线程运行后的结果：使用FutureTask的get方法
        try {
            //如果主运行到这里，发现子线程任务还没跑完，他会让出cpu，等着子线程执行完
            System.out.println(my_future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            System.out.println(my_future2.get());
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}
//1.定义一个实现类，实现callable接口 这是一个泛型接口，实现的时候要声明返回值类型
class MyCallable  implements Callable<String> {

    private final int num;
    public MyCallable(int num) {
        this.num = num;
    }

    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= num; i++) {
            sum += i;
        }
        return "子线程计算1到"+ "num" + "的结果是" + sum;


    }
}