【JavaEE】初步认识多线程

   🔥个人主页： 中草药

🔥专栏：【Java】登神长阶 史诗般的Java成神之路

---

🎷 一.线程

1.概念

3.线程的状态 

线程在Java中具有多种状态，这些状态反映了线程在其生命周期中的不同阶段。了解这些状态对于调试和优化多线程应用至关重要。下面是Java中线程的六种主要状态：

1. NEW（新建）：

   • 当线程对象被创建但尚未调用 start() 方法时，线程处于 NEW 状态。
   • 在此状态下，线程尚未开始执行任何操作。

2. RUNNABLE（可运行）：

   • 线程一旦调用了 start() 方法，就会进入 RUNNABLE 状态。
   • 处于 RUNNABLE 状态的线程可能正在运行，也可能正在等待 CPU 分配时间片以便运行。
   • 当线程被唤醒、从阻塞状态返回或从等待状态返回时，也会进入 RUNNABLE 状态。

3. BLOCKED（阻塞）：

   • 这个术语有时被用来指代线程因等待锁而无法运行的情况。
   • 当线程试图获取某个对象的锁，而该锁正被其他线程持有时，线程就会进入 BLOCKED 状态。
   • 这个状态在 Java 的官方文档中并不直接提及，但它通常指的是线程因同步操作（如 synchronized）而被阻塞的情况。

4. WAITING（等待）：

   • 当线程调用 Object.wait(), Thread.join(), 或 LockSupport.park() 等方法时，它将进入 WAITING 状态。
   • 在这种状态下，线程将放弃所有 CPU 时间，等待其他线程发出特定信号（如 notify() 或 notifyAll()）或达到指定的时间点（如 wait(long timeout) 或 join(long millis)）。
   • 线程在此状态下不会消耗任何 CPU 时间。

5. TIMED_WAITING（定时等待）：

   • 类似于 WAITING 状态，但在 TIMED_WAITING 状态下的线程有一个额外的时间限制。
   • 线程将等待直到被唤醒或超时。
   • 例如，Thread.sleep(long millis), Object.wait(long timeout), 或 LockSupport.parkNanos() 和 LockSupport.parkUntil() 方法会使线程进入 TIMED_WAITING 状态。

6. TERMINATED（终止）：

   • 当线程的 run() 方法执行完毕或由于某种原因（如抛出未捕获的异常）而提前结束时，线程进入 TERMINATED 状态。
   • 终止的线程不能再被重启。

我们可以形象的理解为：

4.进程和线程的区别 

特征	进程 (Process)	线程 (Thread)
基本单位	系统分配资源的最小单位	系统调度和执行的最小        单位
内存空间	每个进程有独立的内存空间	同一进程中的线程共享内存空间
开销	创建和销毁的开销大	创建和销毁的开销小
通信	需要使用进程间通信机制，如管道或套接字	可直接访问共享数据，但需同步机制
影响	一个进程的崩溃不会影响其他进程	一个线程的崩溃可能影响整个进程
调度	上下文切换开销大	上下文切换开销小
从属关系	独立运行	依赖于所属进程
资源隔离	每个进程有独立的资源	线程共享进程的资源
数据共享	数据共享复杂，需IPC	数据共享容易，直接访问共享数据
优先级	每个进程有自己的优先级	线程可以有自己的优先级，受进程优先级影响
执行环境	每个进程有自己的执行环境	同一进程的线程共享执行环境
多核处理器支持	可以在不同核心上并行执行	可以在不同核心上并行执行，但受限于进程调度
安全性	更高的安全性，因为资源隔离	较低的安全性，因为资源共享
应用场景	需要高隔离性和安全性的多任务处理	需要高效并发执行和资源紧密协作的多任务处理

 进程是包含线程的. 每个进程至少有⼀个线程存在，即主线程

 线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对⽤⼾层提供了⼀些 API 供⽤⼾使⽤(例如 Linux 的 pthread 库).

🪗二.Thread

1.创建线程

在Java中创建线程的五种常见方式如下：

1.继承 Thread 类:

        在Java中，你可以通过继承 Thread 类来创建一个新的线程类。然后，你需要重写 run() 方法，将你希望在线程中执行的代码放在这个方法里。创建线程实例后，调用 start() 方法来启动线程。

示例:

1class MyThread extends Thread {
2    public void run() {
3        System.out.println("Thread running");
4    }
5}
6
7public class Main {
8    public static void main(String[] args) {
9        MyThread thread = new MyThread();
10        thread.start();
11    }
12}

2.实现 Runnable 接口:

        另一种创建线程的方式是实现 Runnable 接口，然后将实现的类的实例传递给 Thread 构造函数。同样，你需要实现 run() 方法。

示例

class MyRunnable implements Runnable {public void run() {System.out.println("Runnable running");}
}public class Main {public static void main(String[] args) {Thread thread = new Thread(new MyRunnable());thread.start();}
}

3.匿名内部类 

在Java中，你可以使用匿名内部类来创建线程，无论是通过实现Runnable接口还是通过继承Thread类。下面是如何使用这两种方式创建线程的示例：

实现 Runnable 接口

public class Main {public static void main(String[] args) {// 使用匿名内部类实现 Runnable 接口Thread thread = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Running in thread using Runnable interface.");}});// 启动线程thread.start();}
}

继承 Thread 类

public class Main {public static void main(String[] args) {// 使用匿名内部类继承 Thread 类Thread thread = new Thread() {@Overridepublic void run() {System.out.println("Running in thread by extending Thread class.");}};// 启动线程thread.start();}
}

4.使用 Lambda 表达式

Java 8 引入了Lambda表达式，使得创建线程更加简洁。你可以在创建 Thread 对象时直接提供一个Lambda表达式作为 Runnable。

public class Main {public static void main(String[] args) {Thread thread = new Thread(() -> System.out.println("Lambda running"));thread.start();}
}

2.控制线程

方法	作用
start()	开始执行线程的 run() 方法。
run()	定义线程要执行的操作。直接调用 run() 不会启动新线程；它仅在当前线程中运行。
join()	等待线程终止。join() 方法可接受一个毫秒值参数，表示最多等待的时间。
interrupt()	请求中断线程。这会导致线程的中断状态被设置为 true。
interrupted()	检查并清除当前线程的中断状态。
sleep (long millis)	让当前线程暂停执行指定的毫秒数。
yield():	让当前线程放弃剩余时间片，重新排队等待下一次执行机会。
setName (String name)	设置线程的名字。
setPriority(int priority)	设置线程的优先级，范围是 Thread.MIN_PRIORITY 到 Thread.MAX_PRIORITY。
Thread.currentThread()	获取线程实例

 注意事项

• 不要直接调用 stop() 方法：它已被废弃，因为可能会导致资源泄露和数据不一致。
• 不要随意使用 ThreadDeath: 这是一个特殊的错误，用于终止未正确处理的线程。
• 处理异常：在 run() 方法中抛出的未捕获异常将被 Thread.UncaughtExceptionHandler 处理。

3.常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否为后台进程	isDaemon()
是否存活	isAilve()
是否被中断	isInterrupted()

• 名称是各种调试工具用到
• 状态表示线程当前所处的⼀个情况，下面我们会进⼀步说明
• 优先级⾼的线程理论上来说更容易被调度到
• 关于后台线程，需要记住⼀点：JVM会在⼀个进程的所有⾮后台线程结束后，才会结束运行。
• 是否存活，即简单的理解，为 run 方法是否运行结束了

 🎸三.多线程带来的的风险-线程安全 (重点)

       线程安全（Thread Safety）是在多线程编程中非常关键的一个概念，它涉及到了软件设计和实现中如何确保在多线程环境下，共享资源的访问和操作能够正确无误地进行，不会导致数据的不一致、竞态条件（race conditions）、死锁（deadlocks）或其他同步错误。

1.死锁问题-synchronized

synchronized是Java中用于实现线程同步的关键字，主要用于控制多线程环境下的并发访问，以保证数据的一致性和完整性。synchronized可以用于方法或者代码块，其主要功能是确保同一时刻只有一个线程可以执行特定的代码段，从而避免了数据竞争和不一致的问题。

工作原理

synchronized的关键在于锁的获取和释放。当一个线程进入synchronized代码块或方法时，它会尝试获取与该代码块或方法相关的锁。如果锁已经被另一个线程持有，当前线程就会被阻塞，直到锁被释放。当线程退出synchronized代码块或方法时，它会自动释放锁。

锁的信息存储在Java对象头的Mark Word中，当线程获取锁时，会将Mark Word修改为指向Thread Monitor（监视器）的指针，而当线程释放锁时，Mark Word会恢复原状或更新为新的状态。

synchronized的特性和优势

• 原子性：保证了临界区代码的原子性，即要么全部执行完成，要么全部不执行。
• 可见性：确保了在synchronized块内对共享变量的修改对其他线程可见。
• 有序性：防止了指令重排序，保证了代码执行的顺序。

死锁

        在Java中，死锁是一种线程间的问题，它发生在两个或多个线程相互等待对方持有的锁释放时。当这种情况发生时，所有涉及的线程都将无限期地阻塞，因为每个线程都在等待另一个线程完成某些操作，而那个操作却永远不会发生，除非外部干预。

以下是一个典型的死锁场景：

        假设我们有两个对象ObjectA和ObjectB，以及两个线程Thread1和Thread2。Thread1需要先获取ObjectA的锁，然后获取ObjectB的锁。同时，Thread2需要先获取ObjectB的锁，然后再获取ObjectA的锁。如果Thread1成功获取了ObjectA的锁，但在获取ObjectB的锁之前被中断（例如，由于时间片轮换），此时Thread2尝试获取ObjectB的锁并成功，接下来Thread2试图获取ObjectA的锁，但是ObjectA的锁已经被Thread1持有。这时就形成了一个死锁：

Thread1: 持有ObjectA的锁，等待ObjectB的锁
Thread2: 持有ObjectB的锁，等待ObjectA的锁

死锁的四个必要条件中其中：synchronized关键字在Java中用于实现线程间的互斥和可重入，这是它核心的两个特性，我们只能从代码结构来解决问题，包括请求与保持，循环等待，让我们逐一解析：

互斥性（Mutual Exclusion）

互斥性是指在多线程环境下，一次只有一个线程能够访问某个资源或执行某段代码。在Java中，synchronized关键字通过加锁机制实现了互斥性。当一个线程获得锁并开始执行synchronized代码块或方法时，其他试图获取同一锁的线程将被阻塞，直到持有锁的线程执行完毕并释放锁。

例如，假设我们有两个线程Thread1和Thread2，以及一个对象obj。如果obj的某个方法被synchronized修饰，那么当Thread1正在执行这个方法时，Thread2试图调用该方法将被阻塞，直到Thread1执行完毕并释放锁。这就是互斥性的体现。

可重入性（Reentrancy）

可重入性意味着一个线程可以在已经持有一个锁的情况下再次获取同一个锁，而不会造成死锁。在synchronized的上下文中，这意味着一个线程可以进入一个synchronized代码块或方法，然后在该代码块或方法内部再次进入另一个synchronized代码块或方法，只要这两个synchronized区域的锁是相同的。

在Java中，synchronized实现的锁是可重入的。当一个线程第一次获取锁时，它会增加一个“锁计数”。当该线程离开synchronized代码块或方法时，锁计数减一。只有当锁计数降为零时，锁才被完全释放，允许其他线程获取锁。

例如：

public class ReentrantExample {public synchronized void outer() {System.out.println("Thread " + Thread.currentThread().getName() + " entered outer()");inner();}public synchronized void inner() {System.out.println("Thread " + Thread.currentThread().getName() + " entered inner()");}
}// 在主线程中调用
ReentrantExample reentrantExample = new ReentrantExample();
new Thread(() -> reentrantExample.outer()).start();

        在这个例子中，outer()和inner()方法都被synchronized修饰。当一个线程调用outer()时，它会获取锁。然后，在outer()内部调用inner()，此时线程再次获取相同的锁。由于synchronized锁的可重入性，这不会导致死锁，线程可以正常执行inner()方法，然后在退出inner()和outer()时逐步释放锁。

        互斥性和可重入性是synchronized关键字为Java多线程编程提供的关键特性，它们共同确保了线程安全和资源的正确访问。然而，过度使用synchronized可能会引入性能瓶颈，因为频繁的锁获取和释放会增加线程的等待时间。在现代Java中，为了更高的性能和更细粒度的控制，程序员还可以选择使用java.util.concurrent包中的高级锁机制，如ReentrantLock和ReadWriteLock。

synchronized的缺陷

• 性能开销：由于synchronized需要进行锁的获取和释放，这可能会带来一定的性能开销，特别是在高并发的场景下。
• 死锁风险：如果使用不当，可能会导致死锁，即两个或更多的线程在等待彼此释放锁，从而无法继续执行。

使用synchronized的注意事项

• 尽量减少synchronized代码块的范围，只保护必要的代码。
• 避免在synchronized块中执行长时间的操作，如I/O操作或网络通信。
• 使用锁时要小心，避免死锁和活锁。
• 考虑使用更细粒度的锁，如java.util.concurrent包下的ReentrantLock或ReadWriteLock，以提高并发性能。

synchronized关键字是Java并发编程的基础，掌握其使用和原理对于开发健壮的多线程应用程序至关重要。

2.内存可见性问题-volatile

内存可见性问题在多线程编程中是一个关键概念，特别是在像Java这样的语言中，其中线程间的通信和数据共享是通过共享内存模型实现的。内存可见性问题是指当一个线程修改了一个共享变量的值，而其他线程未能立即看到这个修改，导致程序行为不符合预期的现象。

Java内存模型（JMM）

理解内存可见性问题之前，需要了解Java内存模型（JMM）。JMM定义了程序执行过程中所有线程访问共享变量的抽象行为。根据JMM，所有变量存储在主内存中，每个线程拥有自己的工作内存，其中包含了该线程使用变量的主内存的副本。线程对变量的所有操作（读、写）都在其工作内存中进行，而不是直接在主内存中进行。只有当线程结束或显式同步时，工作内存中的变量值才被写回到主内存中。

内存可见性问题的原因

内存可见性问题主要由以下几个因素引起：

1. 缓存一致性：现代处理器具有多级缓存，以提高性能。当一个线程读取一个变量时，该变量的值可能被缓存在线程的本地缓存中。如果另一个线程修改了这个变量，那么第一个线程可能看不到这个更新，直到缓存一致性协议（如MESI协议）强制刷新缓存。

2. 编译器优化：编译器可能重新排序代码以优化性能，这可能导致对共享变量的读写操作的顺序与源代码中指定的顺序不同。

3. 操作系统调度：操作系统调度可能在不同线程之间切换，导致一个线程的写操作在另一个线程中变得不可见。

解决方案：Volatile关键字

volatile是Java中的一个关键字，主要用于多线程环境下，用来标记那些可能被多个线程共享并可能在多个线程之间发生变化的变量。volatile关键字有以下主要作用：

1. 保证可见性*： 当一个线程修改了volatile变量的值，这个修改将会立即对所有其他线程可见。这是因为volatile变量的读取和写入不会被缓存在寄存器或处理器缓存中，而是直接从主内存中读取和写回到主内存中。这就确保了所有线程看到的是最新的值。

2. 禁止指令重排序*： 在编译器和处理器中，为了优化性能，通常会对指令进行重排序。但是，这种重排序可能会破坏多线程程序中的逻辑顺序。volatile变量禁止了包含它的语句的指令重排序，确保了指令的执行顺序按照代码的书写顺序进行，这对于维持程序的因果关系至关重要。

3. 不保证原子性*： 虽然volatile提供了可见性和禁止指令重排序的能力，但它并不保证复合操作的原子性。例如，i++这样的操作在多线程环境下并不是原子性的，即使i被声明为volatile。这是因为i++涉及到读取、计算和写回三个步骤，而volatile只能保证每次读取和写入的原子性，不能保证整个复合操作的原子性。（因此volatile与synchronized并且互不冲突）

4. 防止编译器优化*： 编译器通常会进行一些优化，比如如果一个变量的值在一个方法中没有改变，那么编译器可能会缓存这个值而不是每次都去读取它。然而，对于volatile变量，编译器不会进行这样的优化，因为volatile变量的值可能在任何时候由其他线程改变。

使用volatile关键字的示例：

public class Counter {private volatile int count = 0;public void increment() {count++;}public int getCount() {return count;}
}

        在这个例子中，count被声明为volatile，这样在多线程环境中，每个线程对count的修改对其他线程都是立即可见的。然而，increment()方法并没有提供原子性，因为在多线程环境中，多个线程可能同时读取count的值，进行自增操作，然后写回，这可能导致竞态条件。

因此，在处理复合操作时，如果需要原子性，应该考虑使用更高层次的并发工具，如java.util.concurrent包中的AtomicInteger，或者使用synchronized关键字来确保代码块的互斥访问。

3.线程饿死问题-wait&notify

在Java中，线程饿死（Thread Starvation）指的是一个或多个线程由于某种原因永远无法获得CPU时间片，从而无法执行其任务的情况。线程饿死通常是由于资源分配不公、线程优先级设置不当、锁竞争过于激烈或者调度策略不合理等原因造成的。

wait() 方法

wait() 方法用于暂停当前线程的执行，并使线程进入等待状态，直到被其他线程唤醒。调用 wait() 方法的对象必须处于同步上下文中，即在 synchronized 块或方法内调用，因为 wait() 方法需要在锁对象上调用。wait() 方法有三种重载形式：

1. void wait()：使当前线程等待，直到其他线程调用此对象的 notify() 或 notifyAll() 方法。
2. void wait(long millis)：使当前线程等待最多 millis 毫秒，之后线程将自动恢复执行。
3. void wait(long millis, int nanos)：类似于第二种形式，但提供了更精确的等待时间控制。

当一个线程调用 wait() 方法后，它会释放调用 wait() 方法的对象上的锁，允许其他线程获取该锁并执行同步代码块。当线程被唤醒后，它将再次尝试获取锁，如果锁可用，则线程将从 wait() 调用处继续执行；如果锁被其他线程占用，则线程将继续等待。

总而言之，wait()方法一共做了三件事：

• 使当前执行代码的线程进行等待。（把线程放在等待队列中）
• 释放当前锁
• 在满足一定条件时被唤醒，重新尝试获取这个锁

wait()结束等待的条件

• 其他线程调用该对象的notify方法
• wait等待时间超时（wait方法提供一个带有timeout参数的版本，来指定等待时间）
• 其他线程调用该等待线程的interrupted方法，导致wait抛出InterruptedException异常

举例

public static void main(String[] args) throws InterruptedException {Object object = new Object();synchronized (object) {System.out.println("等待中");object.wait();System.out.println("等待结束");}
}

wait 要搭配 synchronized 来使⽤. 脱离 synchronized 使⽤ wait 会直接抛出异常.

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐

  制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸