「多线程」多线程入门

目录

什么是线程和进程

线程的生命周期

Java实现多线程的几种方式

1、继承Thread类

2、实现Runnable接口

3、实现Callable接口

4、使用线程池

---

什么是线程和进程

1. 定义：

   • 进程：进程可以被视为运行中的程序实例，是资源分配的基本单位。一个进程包含了独立的内存空间、代码、数据段、文件描述符等。
   • 线程：线程是进程内的一个执行流，是CPU调度和执行的最小单位。一个进程可以包含多个线程，它们共享进程的资源，包括内存空间、文件描述符等。

2. 资源占用：

   • 进程：每个进程都有独立的内存空间和资源，在操作系统中会为每个进程分配一定的系统资源，如内存、文件描述符等。这使得进程之间的资源互相隔离，但也导致了创建、销毁进程的开销较大。
   • 线程：线程是进程内的执行单元，不像进程那样拥有独立的内存空间。线程共享进程的资源，如共享内存、文件等，因此创建、切换和销毁线程的开销相对较小。

3. 并发性与并行性：

   • 进程：由于进程拥有独立的资源，因此多个进程可以同时执行，实现并发性。不同进程之间的执行是相互独立的，进程调度由操作系统负责。
   • 线程：线程是进程内的执行单元，多个线程可以在同一个进程中同时执行，实现并发性。不同线程之间共享进程的资源，因此要注意线程同步与互斥，以避免数据竞争的问题。线程调度由操作系统的线程调度器负责。

4. 通信和同步：

   • 进程：由于进程之间拥有独立的地址空间，实现进程间通信（IPC）需要显式的机制，如管道、消息队列、共享内存等。进程间通信相对复杂，并且需要进行进程间同步。
   • 线程：由于线程共享进程的资源，线程之间的通信更加简单直接，可以直接通过共享内存进行通信。不过，由于线程共享资源，需要进行线程之间的同步，以避免数据竞争和不一致性。

        总结：线程是进程内的执行单元，共享进程的资源，开销较小，适合用于实现并发性；而进程是独立的执行实例，拥有独立的资源，开销较大，适合用于实现资源隔离和并行性。线程之间通信和同步相对简单，进程间通信和同步相对复杂。多线程编程相对容易，但要注意线程安全；多进程编程相对复杂，但可以更好地实现资源隔离和并行执行。        

线程的生命周期

线程的生命周期是指线程从创建到终止的整个过程，包括以下几个状态：

1. 新建状态（New）：当线程对象被创建时，它处于新建状态。此时线程已经分配了必要的资源但尚未开始执行。

2. 就绪状态（Runnable）：当线程处于就绪状态时，表示它已经准备好运行，但还没有获得CPU执行时间片。多个就绪状态的线程会在系统调度器的控制下竞争CPU资源。

3. 运行状态（Running）：当线程被分配到CPU并开始执行时，它进入运行状态。此时线程正在执行其任务代码。

4. 阻塞状态（Blocked）：线程可能由于某些原因（如等待I/O、等待获取锁等）而暂时停止执行。在这种情况下，线程被称为阻塞状态。

5. 等待状态（Waiting）：线程可以通过调用wait()方法、join()方法或LockSupport.park()方法等来进入等待状态，直到其他线程发出相应的通知或条件满足时才会被唤醒。

6. 超时等待状态（Timed Waiting）：线程可以通过调用带有超时参数的sleep()方法、wait()方法、join()方法或LockSupport.parkNanos()等来进入超时等待状态。当超过指定的时间后，线程将自动恢复到就绪状态。

7. 终止状态（Terminated）：线程完成了它的任务或被强制终止后，进入终止状态。在终止状态下，线程释放了它所占用的资源，不再可运行。

        需要注意的是，线程在不同的状态之间进行转换，受到操作系统和虚拟机的控制和调度。可以通过线程的方法（如start()、sleep()、join()、wait()等）来主动控制线程的状态转换，或者由操作系统和虚拟机根据特定情况自动转换线程的状态。

Java实现多线程的几种方式

1、继承Thread类

创建一个继承自 Thread 类的子类，并重写其 run() 方法来定义线程要执行的任务。然后通过创建子类的实例，并调用 start() 方法来启动线程

public class MyThread extends Thread {

    private static final Logger logger = LoggerFactory.getLogger(MyThread.class);

    @Override
    public void run() {
        logger.info("当前线程的名称为:{}", Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            MyThread myThread = new MyThread();
            myThread.start();
        }
    }
}

2、实现Runnable接口

创建一个实现了 Runnable 接口的类，并实现其 run() 方法来定义线程要执行的任务。然后通过创建该类的实例，并将其作为参数传递给 Thread 类的构造方法，最后调用 start() 方法来启动线程

public class MyRunnable implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(MyRunnable.class);

    @Override
    public void run() {
        logger.info("当前线程的名称为:{}", Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }
}

3、实现Callable接口

通过实现 Callable 接口，并重写其 call() 方法来定义带有返回值的线程任务。使用 ExecutorService 的 submit() 方法提交 Callable 对象，并得到一个 Future 对象，通过调用 Future 对象的 get() 方法获取任务的返回值。

public class MyCallable implements Callable<Integer> {
    private static final Logger logger = LoggerFactory.getLogger(MyRunnable.class);

    @Override
    public Integer call() throws Exception {
        Thread.sleep(1000 * 1);
        String name = Thread.currentThread().getName();
        logger.info("当前线程的名称为:{}", name);
        String numberString = name.replaceAll("[^\\d]", "");
        return Integer.parseInt(numberString);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            MyCallable callable = new MyCallable();
            FutureTask<Integer> futureTask = new FutureTask<>(callable);
            Thread thread = new Thread(futureTask);
            thread.start();
            try {
                Integer integer = futureTask.get();
                logger.info("输出线程id:{}", integer);
            } catch (Exception e) {

            }
        }
    }
}

 4、使用线程池

通过使用 ExecutorService 接口及其实现类 Executors 来创建线程池，然后将要执行的任务提交给线程池来执行。这种方式可以有效地管理线程的生命周期，提高线程的重用性和效率。

public class MyExecutors {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Runnable task = new MyTask(i);
            executor.execute(task);
        }
        executor.shutdown();
    }
}


class MyTask implements Runnable {
    private final int taskId;
    public MyTask(int taskId) {
        this.taskId = taskId;
    }
    @Override
    public void run() {
        System.out.println("Task " + taskId + " is running");
    }
}