JAVA多线程

为什么要有多线程

为了提高程序的执行效率，高效的运用计算机的性能，这也是为什么现在程序有着三高问题（高可用、高并发、高性能）的原因。

什么是多线程

线程和进程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。eg: 我们电脑中有QQ、微信、浏览器……，这些都是进程的范围；而在浏览器中，你在浏览bilibili、同时打开的标签页还有CSDN、Github……这些就是线程。总的来说：进程和线程的关系，就是大鱼吃小鱼，饺子包馅的感觉！

并发和并行

并发：在同一时刻，多个线程交替执行

并行：在同一时刻，多个线程同时执行

java中多线程的实现方式

1. 编写多线程类，继承Thread类，并重写run方法

// 自定义一个多线程类，重写run方法
public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"："+i);
        }
    }
}

// 执行函数内开启多线程
public class Thread_01{
    // 使用集成Thread方式实现多线程
    // 1. 继承Thread
    
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread("线程1");
        MyThread myThread2 = new MyThread("线程2");
        // start是调用线程
        myThread1.start();
        myThread2.start();
    }

}

结果：两个线程交替执行

2.实现Runnable接口方式进行实现

// 自己定义一个类实现Runnable接口
public class MyRun implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
        }
    }
}

public class Thread_01{
    public static void main(String[] args) {
        /**
         * 多线程的第二种启动方式：
         * 1. 自己定义一个类实现Runnable接口
         * 2. 重写里面的run方法
         * 3. 创建自己的类的对象
         * 4. 创建已给Thread类的对象，并开启线程
         */
        MyRun myRun1 = new MyRun();
        MyRun myRun2 = new MyRun();
        Thread myrun1 = new Thread(myRun1);
        myrun1.setName("线程1");
        Thread myrun2 = new Thread(myRun2);
        myrun2.setName("线程2");
        myrun1.start();
        myrun2.start();
    }
}

结果：两个线程交替执行

3. 利用Callable接口和Future接口方式实现

import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        // 这里自动装箱了
        return sum;
    }
}

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

public class Thread_01{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 多线程的第三种实现方式：可以获取到线程运行的结果
         * 1. 创建一个类来实现Callable接口
         * 2. 重写call（是有返回值的，表示多线程运行的结果）
         * 3. 创建MyCallable的对象（表示多线程要执行的任务）
         * 4. 创建FutureTask的对象（管理多线程运行的结果）
         * 5. 创建Thread类的对象，并启动（表示线程）
         */

        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(myCallable);
        Thread thread1 = new Thread(integerFutureTask);
        thread1.start();
        Integer integer = integerFutureTask.get();
        System.out.println(integer);
    }
}

结果：两个线程交替执行

4. 总结

常见的成员方法