什么是线程和进程
进程是一个程序的实例,线程是进程中的实体,一个进程有多个线程
线程的创建方式
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子类)