Java 多线程复习

        第一种多线程实现方式——继承Thread类

package Multi_Thread_Review20240913;

/* 实现多线程的第一种方式：继承Thread类 */
/* 继承Thread类，重写其中的run方法，run方法中的代码是线程想要实现的功能 */

public class My_Thread1 extends Thread{

    @Override
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("这是" + getName() + "第" + (i + 1) + "次线程");
        }
    }

}

        第二种多线程实现方式——实现Runnable接口

package Multi_Thread_Review20240913;

/* 实现多线程的第二种方式：实现Runnable接口 */
/* 重写Runnable中的run方法，然后将My_Runnable的实例对象作为Thread构造函数的参数，创建Thread对象 */

public class My_Runnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("这是" + Thread.currentThread().getName() + (i + 1) + "条线程");

        }
    }
}

        第三种多线程实现方式——实现Callable接口

package Multi_Thread_Review20240913;
import java.util.concurrent.Callable;

/* 实现多线程的第三种方法：实现Callable接口 */
/* 重写Callable中的call方法，Callable需要返回值 */
/* 用My_Callable作为FutureTask类构造函数的参数，然后再用FutureTask对象作为Thread构造函数的参数 */

public class My_Callable implements Callable {

    @Override
    public String call() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("这是" + Thread.currentThread().getName() + "的第" + (i + 1) + "次执行");
        }
        return "完成";
    }
}

         测试类

package Multi_Thread_Review20240913;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class MultiThreadExercise1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 并发：单个CPU同时处理多个指令
        * 并行：多个CPU同时处理多个指令
        * */

        /*
        *  进程：正在运行的程序
        *  进程的独立性：进程是一个能够独立运行的基本单位，同时也是系统动态分配资源和调度的独立单位
        *  进程的动态性：进程的实质是程序的一次执行的过程，是动态产生，动态消亡的
        *  进程的并发性：任何进程都可以和其他进程并发执行
        *
        *
        *  线程：是进程中的单个顺序的控制流，是一条执行路径
        *  单线程：若一个进程只有一条执行路径，那么称为单线程程序
        *  多线程：若一个进程有多个执行路径，那么称为多线程程序
        *
        *
        * */

        /* 继承Thread类实现多线程 */
//        My_Thread1 myThread = new My_Thread1();
//        myThread.setName("A线程");
//        My_Thread1 myThread1 = new My_Thread1();
//        myThread1.setName("B线程");
//        myThread.start();
//        myThread1.start();
//
//        /* 实现Runnable接口实现多线程 */
//        My_Runnable myRunnable1 = new My_Runnable();
//        Thread thread1 = new Thread(myRunnable1);
//        thread1.setName("A线程");
//        Thread thread2 = new Thread(myRunnable1);
//        thread2.setName("B线程");
//        thread1.start();
//        thread2.start();

        /* 实现callable接口实现多线程 */
        /* FutureTask 是一个一次性任务，一旦一个线程开始执行它，其他线程就无法再执行同一个任务了 */
        My_Callable myCallable = new My_Callable();
        FutureTask future = new FutureTask(myCallable);
        Thread thread3 = new Thread(future);
        Thread thread4 = new Thread(future);
        thread3.setName("线程A");
        thread4.setName("线程B");
        thread3.start();
        thread4.start();
        System.out.println(future.get());


    }
}