Java-多线程入门

        多线程是指在软件或硬件上实现多个线程并发执行的技术。为了更好地理解多线程，首先需要了解几个基本概念：

了解概念

1.程序

        程序是为完成特定任务、用某种语言编写的一组指令的集合。它是一个静态的概念，通常存储在磁盘或其他非易失性存储器中，说白了就是我们写的代码。

2.进程

        进程是程序的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。

3.线程

        线程是进程中的一个执行单元，是CPU调度和分派的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，但每个线程有自己的栈和寄存器状态。

4.并发

        并发是指多个任务在同一时间段内交替执行，但由于CPU切换任务的速度非常快，给人的感觉像是同时执行。

5.并行

        并行是指多个任务在同一时刻真正的同时执行，这通常需要多核处理器或其他并行处理硬件的支持。

6.cpu核

CPU核是处理器的计算单元，一个多核处理器可以在同一时刻执行多个线程，从而实现并行处理。

基本使用方法

        多线程编程是提高程序并发处理能力的重要手段。下面通过具体的代码示例来展示如何使用多线程

1. 通过继承Thread类

// 通过继承Thread类来创建线程
class MyThread extends Thread {
    // 重写run方法，线程启动后将执行run方法中的代码
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " 执行 " + i);
            try {
                // 线程休眠100毫秒
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 创建两个线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

• MyThread类继承了Thread类，并重写了run方法。
• 在main方法中创建了两个MyThread对象，并调用start方法启动线程。

2. 实现Runnable接口

// 通过实现Runnable接口来创建线程
class MyRunnable implements Runnable {
    // 实现run方法，线程启动后将执行run方法中的代码
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " 执行 " + i);
            try {
                // 线程休眠100毫秒
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        // 创建Runnable对象
        MyRunnable myRunnable = new MyRunnable();
        
        // 创建两个线程对象，并将Runnable对象作为参数传递给Thread构造函数
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

 

• MyRunnable类实现了Runnable接口，并实现了run方法。
• 在main方法中创建了一个MyRunnable对象，并将其作为参数传递给两个Thread对象，然后调用start方法启动线程。

3. 通过Callable和Future创建线程

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

// 通过实现Callable接口来创建线程
class MyCallable implements Callable<Integer> {
    // 实现call方法，线程启动后将执行call方法中的代码，并返回一个结果
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + " 执行 " + i);
            try {
                // 线程休眠100毫秒
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return sum;
    }
}

public class CallableDemo {
    public static void main(String[] args) {
        // 创建Callable对象
        MyCallable myCallable = new MyCallable();
        
        // 创建FutureTask对象，并将Callable对象作为参数传递给FutureTask构造函数
        FutureTask<Integer> futureTask1 = new FutureTask<>(myCallable);
        FutureTask<Integer> futureTask2 = new FutureTask<>(myCallable);
        
        // 创建线程对象，并将FutureTask对象作为参数传递给Thread构造函数
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        
        // 启动线程
        thread1.start();
        thread2.start();
        
        try {
            // 获取线程执行结果
            System.out.println("Thread 1 结果: " + futureTask1.get());
            System.out.println("Thread 2 结果: " + futureTask2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

• MyCallable类实现了Callable接口，并实现了call方法，该方法返回一个整数结果。
• 在main方法中创建了一个MyCallable对象，并将其作为参数传递给两个FutureTask对象。
• 将FutureTask对象作为参数传递给两个Thread对象，并调用start方法启动线程。
• 使用FutureTask的get方法获取线程的执行结果。

总结

     可以看到，Thread实现了Runnable接口 ，他是一个类，我们可以直接继承Thread类来实现线程，也可以通过直接实现Runnable接口来使用，感兴趣的可以自己去看一下源码，然而Threa本身并没有Run方法，Run方法是接口里面的。

         多线程的底层实现机制原理涉及到线程调度、同步和互斥等概念。操作系统通过线程调度器来决定哪个线程在何时执行。为了确保多个线程能够正确地共享资源，需要使用同步机制，如锁（synchronized关键字）和条件变量（如Java中的wait和notify方法）。  多线程想要理解透彻需要花费一定的时间，也有难度，底层原理我会后面再写，今天这篇文章只需要简单了解入门即可。