线程相关个人笔记总结

什么是线程和进程

进程是一个程序的实例,线程是进程中的实体,一个进程有多个线程

线程的创建方式
1.继承 Thread 类重写 run()

创建一个类继承自 Thread 类,并重写 run() 方法来定义线程执行的任务。

通过创建该类的实例并调用 start() 方法来启动线程。

class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}
// 创建线程并启动
MyThread thread = new MyThread();
thread.start();
2.实现 Runnable 接口实现 run() 方法

创建一个实现 Runnable 接口的类,并实现其 run() 方法。

创建该类的实例,然后将其传递给一个新的 Thread 实例,并调用 start() 方法启动线程。

// 写法1:创建一个类实现 Runnable 接口实现 run() 方法
class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}
// 创建线程并启动
Thread thread = new Thread(new MyRunnable());
thread.start();

// 写法2:使用匿名内部类在创建 Thread 或实现 Runnable 接口
Thread thread = new Thread(new Runnable() {
    public void run() {
        // 线程执行的任务
    }
});
thread.start();

// 写法3: Lambda 表达式对匿名内部类方式进行简化
Thread thread = new Thread(() -> {
    // 线程执行的任务
});
thread.start();
3.使用 Callable 和 Future:

创建一个实现 Callable 接口的类,实现 call() 方法。

使用 ExecutorService 提交 Callable 任务,返回一个 Future 对象,通过 Future 获取线程执行的结果。

class MyCallable implements Callable<String> {
    public String call() {
        // 线程执行的任务
        return "Task completed!";
    }
}

// 使用 ExecutorService 创建线程并启动
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new MyCallable());
try {
    String result = future.get();
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
executor.shutdown();
线程生命周期
 public enum State {
        // 创建:Thread 实例刚刚被创建,但尚未开始执行。
        NEW,
     
    	// 就绪:调用 start() 方法进入就绪状态,等待获取CPU时间片,
     	// 获取后进入运行状态,开始执行run() 方法中的任务。
        RUNNABLE,
     
    	// 阻塞:线程被阻塞,暂时停止执行,
     	// 一般在获取锁(synchronized,ReentrantLock)时被其他线程占用,或是等待I/O操作完成会进入阻塞
        BLOCKED,

    	// 等待:线程进入等待状态,需要被手动唤醒。
		// 调用 Object.wait()、Thread.join()、LockSupport.park() 等方法会使线程进入等待状态。
        WAITING,

    	// 超时等待:线程等待一定时间后自动唤醒。
		// 调用 Thread.sleep(timeout)、Object.wait(timeout)、Thread.join(timeout) 等方法会使线程进入超时等待状态。
        TIMED_WAITING,

        // 终止:线程的生命周期结束,如线程执行完任务,或者出现异常而结束
        TERMINATED;
    }
什么是ThreadLocal,可以用来做什么,怎么使用

ThreadLocal是线程级别的变量容器。每个线程都可以独立访问自己的 ThreadLocal 变量,线程之间互不影响。

一般可以用来传参,或是多线程下需要实现线程局部变量

// 创建 ThreadLocal 变量:(创建类型有多种)
private static ThreadLocal<MyObject> myObjectThreadLocal = ThreadLocal.withInitial(() -> new MyObject());
ThreadLocal.withInitial(() -> 0);
ThreadLocal.withInitial("wrxfxdd");(文本)
ThreadLocal.withInitial(() -> false);
ThreadLocal.withInitial(User:new);(对象)
ThreadLocal.withInitial(HashMap::new);(集合)

// 设置线程局部变量的值
myObjectThreadLocal.set(new MyObject());
// 获取线程局部变量的值:
MyObject myObject = myObjectThreadLocal.get();
// 移除线程局部变量的值(
myObjectThreadLocal.remove();
什么是守护线程,用来做什么,怎么用

守护线程是在程序运行时在后台提供服务的线程。守护线程只有在普通线程全部结束后,jvm退出,才会终止

一般用来执行一些后台任务,如垃圾回收、内存管理等,例如,JVM 中的垃圾回收线程就是一个守护线程。但平时代码中很少用到,

Thread daemonThread = new Thread(() -> {
    while (true) {
        // 守护线程的逻辑
    }
});
daemonThread.setDaemon(true);
daemonThread.start();
线程类的常用方法
Thread.join(),(毫秒)

join是线程实例的方法 ,调用 join() 方法的这个实例线程会被阻塞,直到线程结束或者使用重载的join(时间)方法,如果超过该时间没有结束,当前线程就会继续执行。用于可以按照一定顺序执行线程任务

Thread.sleep(毫秒);

sleep()是Thread类直接调用的方法,会让当前线程(一般是主线程)进入超时等待状态,超过该时间自动恢复就绪状态,可用于模拟耗时,或debug比如异步是否生效等

notify(); notifyAll():

notify() notifyAll() 方法都是object类的,notify():如果有多个线程处于等待中,只会随机唤醒一个处于等待状态(通过wait()方法进入等待状态)的线程。notifyAll() :唤醒所有处于等待状态的线程。

object.wait(),(毫秒);

wait() 方法是object类的,会让当前线程会释放对象的锁(即释放 synchronized 同步块的锁),并进入等待状态,直到被相同对象的object调用 notify() 或 notifyAll() 唤醒,主要用于线程间的同步和通信

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean flag = false;

    public void waitForFlag() throws InterruptedException {
        synchronized (lock) {
            while (!flag) {
                System.out.println("Waiting...");
                lock.wait();
            }
            System.out.println("Flag is true. Continue with the task.");
        }
    }

    public void setFlag() {
        synchronized (lock) {
            flag = true;
            lock.notifyAll();
        }
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread waitingThread = new Thread(() -> {
            try {
                example.waitForFlag();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread notifyingThread = new Thread(() -> {
            // Simulate some work
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Setting the flag to true.");
            example.setFlag();
        });
        waitingThread.start();
        notifyingThread.start();
    }
}
注意事项

使用 wait() 方法,线程必须通过synchronized获取对象的锁,否则运行时会抛出 IllegalMonitorStateException 异常(因为wait()方法是Object类的方法,它要求在对象的监视器(即通过synchronized关键字获取锁而ReentrantLock是juc下的实现,不是Object子类)

相关推荐
Justinc.3 分钟前
CSS3新增边框属性(五)
前端·css·css3
武子康9 分钟前
大数据-212 数据挖掘 机器学习理论 - 无监督学习算法 KMeans 基本原理 簇内误差平方和
大数据·人工智能·学习·算法·机器学习·数据挖掘
neter.asia19 分钟前
vue中如何关闭eslint检测?
前端·javascript·vue.js
~甲壳虫20 分钟前
说说webpack中常见的Plugin?解决了什么问题?
前端·webpack·node.js
passer__jw76737 分钟前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode
代码之光_198038 分钟前
保障性住房管理:SpringBoot技术优势分析
java·spring boot·后端
光影少年39 分钟前
vue2与vue3的全局通信插件,如何实现自定义的插件
前端·javascript·vue.js
As977_40 分钟前
前端学习Day12 CSS盒子的定位(相对定位篇“附练习”)
前端·css·学习
susu108301891142 分钟前
vue3 css的样式如果background没有,如何覆盖有background的样式
前端·css