多线程解析

Lentou

于 2023-07-23 19:12:45 发布

阅读量95

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_45035042/article/details/131881234

版权

多线程

基本概念
进程是电脑程序运行的最小单位，而线程则是进程的最小执行单位，一个进程可以有多个线程。

为了解决进程调度资源的浪费，为了能够共享资源，出现了线程。

线程: 线程是CPU调度和分派的基本单位，一个进程中,可以同时有多条执行链路, 这些执行链路称为线程, 线程是比进程更小的执行单位，同一个进程多个线程共享这个进程的内存资源:多个线程共享内存，从而极大地提高了程序的运行效率。

在这里插入图片描述

生命周期

1、新建：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序
start() 这个线程

2、就绪：当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

3、运行：如果就绪状态的线程获取 CPU 资源，就可以执行
run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

4、阻塞：执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
可以分为三种： **等待阻塞，**运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞，线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞，通过调用线程的 sleep() 或 join() 发出了I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O处理完毕，线程重新转入就绪状态。

5、死亡：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

在这里插入图片描述

NEW,新建:
线程刚被创建，还没调用start方法，或者刚刚调用了start方法，调用start方法不一定"立即"改变线程状态，中间可能需要一些步骤才完成一个线程的启动。
可运行,RUNNABLE:
start方法调用结束,线程由NEW变成RUNNABLE，线程存活着，并尝试抢占CPU资源，或者已经抢占到CPU资源正在运行，这俩种情况的状态都显示为RUNNABLE
锁阻塞,BLOCKED:
线程A和线程B都要执行方法test，而且方法test被加了锁，线程A先拿到了锁去执行test方法，线程B这时候需要等待线程A把锁释放。这时候线程B就是处理BLOCKED。
无限期等待，WAINTING：
一个线程在等待另一个线程执行一个(唤醒）动作时，该线程进入WAITING期,进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
有限期等待，TIMED_WAITING：
和WAITING状态类似，但是有一个时间期限，时间到了，自己也会主动醒来
终止(死亡），TERMINATED：
run方法执行结束的线程处于这种状态。
在图中可以看到，BLOCKED，WAITING，TIMED＿WAITING这三种都属于线程阻塞，知识触发条件以及从阻塞状态恢复过来的条件不同。
线程在这三种情况的阻塞下，都具备：
线程不执行代码
线程不参与CPU时间片的争夺

多线程：是指从软件或者硬件上实现多个线程并发执行的技术，多线程包括软件多线程和硬件多线程。

软件多线程：即便处理器只能运行一个线程，操作系统也可以通过快速的在不同线程之间进行切换，由于时间间隔很小，来给用户造成一种多个线程同时运行的假象。

**进程：**是指计算机中已运行的程序.

**并行：**并列运行，多个CPU下支持。多个cpu执行各种不同任务

并发：多个任务请求运行，CPU轮流交替运行。一个CPU执行不同的任务（多个线程）。

**进程和线程区别：**一个应用程序启动一个进程，一个进程可以有多个线程

**多线程优点：**程序运行速度快、执行程序可以后台运行、提高响应效果

**多线程缺点：**多线程共享堆内存和方法区（存在线程安全的问题）栈内存不共享，启动多线程晖占用更多内存（资源消耗增多）

**线程池：**面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。

实现方式

1. 继承Thread类

	编写一个类继承Thread,该类是线程类
	重写run(), 编写该线程需要完成的任务
	创建线程类对象
	调用start()方法,启动线程

public class MyThread extends Thread {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    // 重写 run 方法，在线程启动后执行的代码放在这里
    public void run() {
        System.out.println("线程 " + name + " 正在运行");
    }

    public static void main(String[] args) {
        // 创建线程对象并启动线程
        Thread thread1 = new MyThread("Thread 1");
        Thread thread2 = new MyThread("Thread 2");

        thread1.start();
        thread2.start();

        try {
            // 等待线程执行结束
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有线程执行结束");
    }
}

注意：

线程启动,一定是调用start() , 不是调用run(), 如果直接调用run() ,只是方法的调用,没有创建线程。一个线程一旦启动,就不能重复启动

2. 实现Runnable接口：接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。

　实现步骤：  
　①、定义类实现Runnable接口
　②、覆盖Runnable接口中的run方法将线程要运行的代码放在该run方法中。
　③、通过Thread类建立线程对象。
　　④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
　　⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

public class MyRunnable implements Runnable {
    private String name;

    public MyRunnable(String name) {
        this.name = name;
    }

    // 实现 run 方法，在线程启动后执行的代码放在这里
    public void run() {
        System.out.println("线程 " + name + " 正在运行");
    }

    public static void main(String[] args) {
        // 创建实现 Runnable 接口的对象
        Runnable runnable1 = new MyRunnable("Thread 1");
        Runnable runnable2 = new MyRunnable("Thread 2");

        // 创建线程对象，并将实现 Runnable 接口的对象作为构造参数传入
        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        // 启动线程
        thread1.start();
        thread2.start();

        try {
            // 等待线程执行结束
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("所有线程执行结束");
    }
}

继承Thread与Runnable接口的区别:

继承Thread类, 这个线程类就不能再继承其他类, 实现Runnable接口, 可以再继承其他类

实现Runnable接口, 可以让多个线程共享这个Runnable的实现类对象

继承Thread类,启动简单, 实现Runnable接口, 必须依赖Thread类的start()方法

3. 实现Callnable接口搭配Futrue Task使用
实现步骤：
①编写一个类实现Callable接口,重写call()方法，该方法作为线程执行体，且具有返回值

	启动线程

	②创建Callable接口实现类对象，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call（）方法的返回值。

	③创建一个FutureTask对象, 传递Callable接口实现类对象, FutureTask异步得到Callable执行结果, 提供get() FutureTask 实现Future接口( get()) 实现Runnable接口

	创建一个Thread对象, 把FutureTask对象传递给Thread, 调用start()启动线程

三种方式的区别

采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。　　　
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式： (推荐使用的方式)
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
采用实现Callable接口：
（1）Callable规定的方法是call(),
（2）call方法可以抛出异常，run方法不可以
（3）Callable的任务执行后可返回值，而Runnable的任务是不能返回值
（4）运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

import java.util.concurrent.*;

public class MyCallable implements Callable<Integer> {
    private String name;

    public MyCallable(String name) {
        this.name = name;
    }

    // 实现 call 方法，在线程启动后执行的代码放在这里
    public Integer call() {
        System.out.println("线程 " + name + " 正在运行");
        // 返回一个计算结果
        return name.length();
    }

    public static void main(String[] args) {
        // 创建实现 Callable 接口的对象
        Callable<Integer> callable1 = new MyCallable("Thread 1");
        Callable<Integer> callable2 = new MyCallable("Thread 2");

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        try {
            // 提交任务并获取 Future 对象
            Future<Integer> future1 = executorService.submit(callable1);
            Future<Integer> future2 = executorService.submit(callable2);

            // 获取任务的执行结果
            int result1 = future1.get();
            int result2 = future2.get();

            System.out.println("线程 1 的结果：" + result1);
            System.out.println("线程 2 的结果：" + result2);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            executorService.shutdown();
        }

        System.out.println("所有线程执行结束");
    }
}

线程池

线程池

使用Executos工具去创建

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池中的线程最大数量是Integer.MAX_VALUE，int类型的最大值。如果线程的处理速度小于任务的提交速度时，会不断创建新的线程来执行任务，这样有可能会因为创建过多线程而耗尽CPU 和内存资源。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        // 创建缓存线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskIndex = i;
            executorService.execute(() -> {
                System.out.println("执行任务 " + taskIndex + "，线程名称：" + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

newFixedThreadPool ：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。固定大小线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小为4的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskIndex = i;
            executorService.execute(() -> {
                System.out.println("执行任务 " + taskIndex + "，线程名称：" + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

newScheduledThreadPool ：创建一个定长线程池，支持定时及周期性任务执行。定时任务线程池。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        // 创建定时任务线程池
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

        // 延迟1秒后执行任务
        scheduledExecutorService.schedule(() -> {
            System.out.println("任务一，线程名称：" + Thread.currentThread().getName());
        }, 1, TimeUnit.SECONDS);

        // 延迟2秒后执行周期性任务，每隔3秒执行一次
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("任务二，线程名称：" + Thread.currentThread().getName());
        }, 2, 3, TimeUnit.SECONDS);

        // 关闭线程池
        scheduledExecutorService.shutdown();
    }
}

newSingleThreadExecutor ：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // 创建单线程线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskIndex = i;
            executorService.execute(() -> {
                System.out.println("执行任务 " + taskIndex + "，线程名称：" + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

解决多线程安全

使用synchronized：可以使用 synchronized 关键字来确保在同一时间只有一个线程可以访问共享资源。当一个线程进入 synchronized 块时，它会获取对象的锁定，其他线程必须等待当前线程释放锁定后才能访问共享资源。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

使用lock接口：除了 synchronized 关键字之外，还可以使用 Lock 接口来实现线程安全。Lock 接口提供了更灵活的锁定机制，包括可重入锁、读写锁等。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;//引入了 ReentrantLock 类，它是 Lock 接口的一个具体实现，用于创建可重入锁对象。

public class Counter {
    private int count = 0;
    //声明了一个私有的 Lock 类型的变量 lock，并使用 ReentrantLock 的实例进行初始化，用于实现线程同步。
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();//调用 lock 对象的 lock() 方法，获取锁，确保只有一个线程能够执行下面的代码块。
        try {
            count++;
        } finally {
            lock.unlock();//调用 lock 对象的 unlock() 方法，释放锁资源。
        }
    }

    public int getCount() {
        lock.lock();//调用 lock 对象的 lock() 方法，获取锁，确保在获取计数器的值时其他线程无法修改。
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

3、使用原子类：Java 提供了一些原子类，如 AtomicInteger、AtomicLong 等，它们提供了原子操作（无锁定机制）。原子类可以在多线程环境下安全地进行增减操作。

import java.util.concurrent.atomic.AtomicInteger;
//它提供了一种线程安全的整型变量。

public class Counter {
//声明了一个私有的 AtomicInteger 变量 count，并使用初始值 0 进行初始化。
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
    //调用 AtomicInteger 对象的 incrementAndGet() 方法，原子性地将计数器的值增加 1，并返回增加后的值
        count.incrementAndGet();
    }

    public int getCount() {
    //调用 AtomicInteger 对象的 get() 方法，获取计数器的当前值
        return count.get();
    }
}

在上述代码中，我们使用了 AtomicInteger 类来替代普通的 int 类型，并分别使用了 incrementAndGet 和 get 方法来实现增加和获取值的操作。这些方法都是原子性的，无需显式地加锁

Lentou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程解析

基本概念进程是电脑程序运行的最小单位，而线程则是进程的最小执行单位，一个进程可以有多个线程。为了解决进程调度资源的浪费，为了能够共享资源，出现了线程。线程是CPU调度和分派的基本单位，一个进程中,可以同时有多条执行链路, 这些执行链路称为线程,，同一个进程多个线程共享这个进程的内存资源:多个线程共享内存，从而极大地提高了程序的运行效率。
复制链接

扫一扫