网站开发者模式有什么用,海口官网设计,设计网站公司收费,网站界面切片做程序一#xff1a;多线程带来的的风险-线程安全
线程安全的概念#xff1a;如果多线程环境下代码运行的结果是符合我们预期的#xff0c;即在单线程环境应该的结果#xff0c;则说这个程序是线程安全的。
当多个线程同时访问共享资源时#xff0c;就会产生线程安全的风险多线程带来的的风险-线程安全
线程安全的概念如果多线程环境下代码运行的结果是符合我们预期的即在单线程环境应该的结果则说这个程序是线程安全的。
当多个线程同时访问共享资源时就会产生线程安全的风险下面通过一段代码演示
static class Counter {public int count 0;void increase() {count;}
}
public static void main(String[] args) throws InterruptedException {final Counter counter new Counter();Thread t1 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});Thread t2 new Thread(() - {for (int i 0; i 50000; i) {counter.increase();}});t1.start();t2.start();t1.join();//主线程等待t1线程结束t2.join();//主线程等待t2线程结束System.out.println(counter.count);
}这个代码,是两个线程针对同一个变量各自自增 5w 次.
运行程序,预期结果应该是10w 实际是个随机值一样。每次的结果还不一样。
实际结果和预期结果不相符,就是 bug 由多线程引起的 bug 线程不安全/线程安全问题
那么为什么会出现这个情况呢
count 操作本质上是三个cpu 指令构成~~
load,把内存中的数据读取到cpu寄存器中.add,就是把寄存器中的值,进行1运算save,把寄存器中的值写回到内存中. 由于多线程调度顺序是不确定的,实际执行过程中,这俩线程的操作实际的指令排列顺序就有很多可能!!! 等等等等许多的组合
1.1 组合1 对于这种组合来说
第一步 第二步t1-load 第三步(t1-add): 第四步t1-save 第五步t2-load 第六步t2-add 第七步t2-save 这种组合是没有问题的能够无误的完成自增。
1.2 组合2 但是对于这种组合来说就有点问题了
第一步 第二步(t1-load) 第三步(t2-load): 第四步t2-add 第五步t1-add 第六步t1-save 第七步t2-save 这就和我们的预期结果2不一致了因为这有类似脏读的数据一切罪恶的根源就是cpu调度的抢占式执行这就是多线程带来的风险。
当我们修改共享数据的时候就很容易发生线程不安全的情况
上面的线程不安全的代码中 涉及到多个线程针对 counter.count 变量进行修改。此时这个 counter.count 是一个多个线程都能访问到的数据”counter.count 这个变量就是在堆上。 因此可以被多个线程共享访问。 当我们用一个线程修改同一个变量 - 安全 多个线程读取同一个变量 - 安全 多个线程修改不同的变量 - 安全 多个线程修改同一个变量 - 不安全
1.3 原子性
多个线程修改同一个变量不安全的原因主要是因为修改变量的操作不是原子性的
原子性是指一个操作是不可中断的要么全部执行完成要么完全不执行。在多线程编程中原子性保证了在并发环境下对共享资源进行操作时的正确性和一致性。
如果一个操作是原子的那么在执行过程中不会被其他线程的干扰同时也不会干扰其他线程的执行。当多个线程同时对共享资源进行读写操作时如果没有原子性保证就会导致数据不一致、并发错误、死锁等问题。因此在并发编程中需要特别注意保证操作的原子性。
1.4 可见性
可见性问题是指一个线程对共享变量的修改可能不会立即被其他线程所看到导致线程间的数据不一致性。
在多线程环境中每个线程都有自己的工作内存其中包含了该线程使用到的共享变量的副本。当线程对共享变量进行读写操作时实际上是在操作自己工作内存中的副本而不是直接操作主内存中的真实变量。
当一个线程对共享变量进行修改后必须将修改后的值刷新到主内存中以便其他线程可以看到这个变化。而其他线程在读取共享变量时也需要将主内存中最新的值加载到自己的工作内存中。
可见性问题主要有以下两种情况
修改后的值没有立即被其他线程看到当一个线程修改了共享变量的值但该值并没有被及时刷新到主内存中其他线程在读取该共享变量时仍然看到的是过期的旧值而不是最新的修改值。对共享变量的修改对其他线程来说是不可见的一个线程修改了共享变量的值并已经将其写入主内存而其他线程在读取共享变量时却没有及时从主内存中加载最新的值而是仍然从自己的工作内存中读取旧值。
可见性问题可能导致线程安全问题因为不同线程之间对共享变量的读写操作是不同步的。如果一个线程在写入一个共享变量时另一个线程在读取该共享变量时没有及时看到最新的值就会导致数据的不一致性和错误的结果。
Java 内存模型 (JMM): Java虚拟机规范中定义了Java内存模型.目的是屏蔽掉各种硬件和操作系统的内存访问差异以实现让Java程序在各种平台下都能达到一致的并发效果. 线程之间的共享变量存在 主内存 (Main Memory).每一个线程都有自己的 “工作内存” (Working Memory) .当线程要读取一个共享变量的时候, 会先把变量从主内存拷贝到工作内存, 再从工作内存读取数据.当线程要修改一个共享变量的时候, 也会先修改工作内存中的副本, 再同步回主内存.
由于每个线程有自己的工作内存, 这些工作内存中的内容相当于同一个共享变量的 “副本”. 此时修改线程1 的工作内存中的值, 线程2 的工作内存不一定会及时变化.
初始情况下, 两个线程的工作内存内容一致. 一旦线程1 修改了 a 的值, 此时主内存不一定能及时同步. 对应的线程2 的工作内存的 a 的值也不一定能及时同步. 这个时候代码中就容易出现问题.
此时引入了两个问题: 一为啥要整这么多内存? 二为啥要这么麻烦的拷来拷去? 为啥整这么多内存? 实际并没有这么多 “内存”. 这只是 Java 规范中的一个术语, 是属于 “抽象” 的叫法.所谓的 “主内存” 才是真正硬件角度的 “内存”. 而所谓的 “工作内存”, 则是指 CPU 的寄存器和高速缓存. 为啥要这么麻烦的拷来拷去? 因为 CPU 访问自身寄存器的速度以及高速缓存的速度, 远远超过访问内存的速度(快了 3 - 4 个数量级, 也就是几千倍, 上万倍).
比如某个代码中要连续 10 次读取某个变量的值, 如果 10 次都从内存读, 速度是很慢的. 但是如果只是第一次从内存读, 读到的结果缓存到 CPU 的某个寄存器中, 那么后 9 次读数据就不必直接访问内存了. 效率就大大提高了.
那么接下来问题又来了, 既然访问寄存器速度这么快, 还要内存干啥??
答案就是一个字: 贵 1.5指令重排序
指令重排序是编译器和处理器为了优化代码执行效率而进行的一种手段。它可以改变代码中指令的执行顺序.
编译器和处理器进行指令重排序的目的是通过优化指令的执行顺序减少指令之间的依赖性提高指令级并行度从而提高程序的执行效率。
JVM 和 CPU 指令集对指令重排序进行优化的原因是提高代码执行效率减少指令的等待时间充分利用处理器的并行执行能力提高程序的性能和响应能力。
尽管指令重排序可以改善程序的执行效率但在多线程环境下指令重排序可能会导致线程安全问题。因此在编写多线程代码时需要使用适当的同步机制来保证线程之间的正确交互。
二解决线程安全问题
2.1 synchronized关键字
如何解决线程不安全问题?需要从原因入手能否让 count变成原子的呢?当然有加锁!!
在Java中可以使用synchronized关键字来保证原子性。synchronized关键字用于修饰方法或代码块确保同一时刻只有一个线程可以执行被修饰的代码。
同步方法将关键字synchronized直接应用于方法。当一个线程进入这个方法时它将锁住整个方法其他线程必须等待该线程执行完毕才能进入该方法。
public synchronized void synchronizedMethod() {// 线程安全代码
}同步代码块将关键字synchronized应用于代码块指定一个对象作为锁。当一个线程进入代码块时它将锁住指定的对象其他线程必须等待锁的释放才能进入该代码块当这个线程执行完代码块的代码时会自动解锁。
public void synchronizedBlock() {synchronized (lock) {// 线程安全代码}
}加锁的意思就是获取到锁解锁的意思就说释放锁加锁意味着获得对某个资源的独占访问权限而解锁则是释放这个资源使其他线程可以访问它。
在以上示例中lock可以是任意Java对象。如果多个线程共享同一个锁对象那么同一时刻只能有一个线程执行代码块内的代码。
synchronized关键字通过获取和释放锁来实现原子性。当一个线程获取到锁时其他线程将无法进入相同的同步方法或代码块。这确保了被synchronized修饰的代码在同一时刻只能由一个线程执行从而保证了原子性。
当两个线程对同一个对象加锁时它们会争夺这个对象的锁资源即发生了锁竞争。只有一个线程能够获得该对象的锁资源而另一个线程将被阻塞直到获得锁的线程释放锁资源。如果两个线程针对不同的对象加锁是不会发生锁竞争的各自获取各自的锁即可。
下面是一个简单的代码示例展示了两个线程对同一个对象进行加锁的情况
public class LockExample {private final Object lock new Object();public void thread1() {synchronized (lock) {// 临界区1// 线程1获得了锁资源执行一些操作}}public void thread2() {synchronized (lock) {// 临界区2// 线程2获得了锁资源执行一些操作}}
}在上面的代码示例中lock对象是一个共享资源两个线程thread1()和thread2()分别对lock对象进行加锁。
当线程1执行到synchronized (lock)时它会尝试获取lock对象的锁资源。如果锁资源可用线程1将获得锁并执行临界区1的代码。此时如果线程2尝试执行synchronized (lock)它将无法获得锁资源因为锁资源已经被线程1占用。线程2将被阻塞直到线程1释放锁资源。
同样地当线程2执行到synchronized (lock)时它会尝试获取lock对象的锁资源。如果锁资源可用线程2将获得锁并执行临界区2的代码。此时如果线程1尝试执行synchronized (lock)它将无法获得锁资源因为锁资源已经被线程2占用。线程1将被阻塞直到线程2释放锁资源。
理解 “阻塞等待”
针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁.
注意:
上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 “唤醒”. 这也就是操作系统线程调度的一部分工作.
假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则.
2.1.1synchronized 的特性
当谈到synchronized关键字时它具有三个重要的特性互斥性、内存可见性和可重入性。下面将逐个解释这些特性
互斥性 synchronized关键字用于保护临界区确保同时只有一个线程可以执行临界区代码。这意味着当一个线程进入synchronized代码块时其他线程将被阻塞直到该线程执行完临界区代码并释放锁。
互斥性保证了线程之间不会相互干扰避免了竞态条件race condition和数据不一致的问题。
内存可见性
synchronized 的工作过程:
获得互斥锁从主内存拷贝变量的最新副本到工作的内存执行代码将更改后的共享变量的值刷新到主内存释放互斥锁
synchronized关键字还确保了线程之间的内存可见性。当线程进入synchronized代码块并获取锁时它会把修改后的值刷新回主内存并且当其他线程获取锁时它们会重新从主内存中读取最新的值。这确保了共享变量的值在不同线程之间保持一致。
内存可见性避免了线程之间读取过时的数据或者脏数据确保了程序的正确性和可靠性。
可重入性 synchronized 同步块对同一条线程来说是可重入的不会出现自己把自己锁死的问题
理解 “把自己锁死” 一个线程没有释放锁, 然后又尝试再次加锁.
// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待.
lock();按照之前对于锁的设定, 第二次加锁的时候, 就会阻塞等待. 直到第一次的锁被释放, 才能获取到第二个锁. 但是释放第一个锁也是由该线程来完成, 结果这个线程已经躺平了, 啥都不想干了, 也就无法进行解锁操作. 这时候就会死锁。 Java 中的 synchronized 是 可重入锁, 因此没有上面的问题.
代码示例
static class Counter {public int count 0;synchronized void increase() {count;}synchronized void increase2() {increase();}
}在上述的代码中, increase 和 increase2 两个方法都加了 synchronized, 此处的 synchronized 都是针对 this 当前对象加锁的.
在调用 increase2 的时候, 先加了一次锁, 执行到 increase 的时候, 又加了一次锁. (上个锁还没释放, 相当于连续加两次锁)
这个代码是完全没问题的. 因为 synchronized 是可重入锁.
在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息. 如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增 解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)
2.2.2synchronized的锁对象
直接修饰普通方法: 相当于对this加锁
public class SynchronizedDemo {public synchronized void methond() {}
}修饰静态方法: 相当于对类对象加锁
public class SynchronizedDemo {public synchronized static void method() {}
}修饰代码块: 明确指定锁哪个对象.
锁当前对象
public class SynchronizedDemo {public void method() {synchronized (this) {}}
}锁类对象
public class SynchronizedDemo {public void method() {synchronized (SynchronizedDemo.class) {}}
}我们重点要理解synchronized 锁的是什么. 两个线程竞争同一把锁, 才会产生阻塞等待.
2.2.3 Java 标准库中的线程安全类
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施.
ArrayListLinkedListHashMapTreeMapHashSetTreeSetStringBuilder
但是还有一些是线程安全的. 使用了一些锁机制来控制.
Vector (不推荐使用)HashTable (不推荐使用)ConcurrentHashMapStringBuffer StringBuffer 的核心方法都带有 synchronized .
还有的虽然没有加锁, 但是不涉及 “修改”, 仍然是线程安全的
String
2.2volatile 关键字
volatile关键字在Java中用于确保多线程环境下的变量在不同线程之间的可见性。当一个变量被声明为volatile时它的值会被强制从主内存中读取而不是从线程的本地缓存中读取。
在多线程环境中每个线程都有自己的本地缓存这样可以提高运行效率。然而由于本地缓存与主内存之间的同步延迟当一个线程修改了变量的值时其他线程可能无法立即感知到这个修改而继续读取本地缓存中的旧值。这就导致了内存可见性问题。
而volatile关键字的作用就是解决这个问题。当一个变量被声明为volatile时所有对该变量的读写操作都会直接同步到主内存中这样其他线程就能够及时地看到最新的值。换句话说volatile关键字可以防止指令重排序优化并保证读写操作的顺序性和原子性。
代码在写入 volatile 修饰的变量的时候,
改变线程工作内存中volatile变量副本的值将改变后的副本的值从工作内存刷新到主内存
代码在读取 volatile 修饰的变量的时候,
从主内存中读取volatile变量的最新值到线程的工作内存中从工作内存中读取volatile变量的副本
加上 volatile , 强制读写内存. 速度是慢了, 但是数据变的更准确了.
注意volatile关键字只能保证变量的可见性并不能解决线程安全问题。如果多个线程同时修改一个变量的值那么仍然会存在竞态条件和数据一致性问题。在这种情况下需要使用synchronized关键字或其他线程安全的机制来保证数据的一致性。
下面是一个简单的示例演示了volatile关键字的使用
public class Worker implements Runnable {private volatile boolean isRunning true;public void run() {while (isRunning) {// 业务逻辑}}public void stop() {isRunning false;}
}在上述代码中isRunning变量被声明为volatile所以当调用stop()方法时其他线程能够立即看到isRunning变量的修改从而终止循环并停止线程的执行。
volatile还有一个效果禁止指令重排序
注意
synchronized 既能保证原子性, 也能保证内存可见性.volatile只能保证内存可见性不能保证原子性
三wait 和 notify
由于线程之间是抢占式执行的因此线程之间执行的先后顺序难以预知但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序。
完成这个协调工作, 主要涉及到这几个个方法
wait() / wait(long timeout): 让当前线程进入等待状态.notify() / notifyAll(): 唤醒在当前对象上等待的线程.
注意: wait, notify, notifyAll 都是 Object 类的方法.
3.1 wait
对于Java中的wait它是一个用于多线程同步的方法。下面是关于wait方法的解释 wait使当前执行代码的线程进行等待并将线程放入等待队列中。同时wait方法会释放当前的锁让其他线程有机会获得这个锁。 wait方法必须与synchronized关键字一起使用。如果在没有synchronized的代码块中使用wait方法会直接抛出异常。 wait方法在满足以下条件之一时结束等待 其他线程调用了该对象的notify方法唤醒了等待线程。等待时间超时。wait方法提供了一个带有timeout参数的版本可以指定等待的时间。其他线程调用了等待线程的interrupted方法导致wait方法抛出InterruptedException异常。
wait方法必须在synchronized代码块或synchronized方法中使用的主要原因是它依赖于对象的监视器也称为锁。当一个线程调用wait方法时它会释放持有的锁然后进入等待状态直到其他线程调用相同对象上的notify或notifyAll方法来唤醒它。
在没有synchronized的代码块中调用wait方法会导致IllegalMonitorStateException异常。这是因为wait方法需要获取对象的监视器才能释放锁并等待而没有synchronized关键字的代码块无法给对象上锁。因此调用wait方法会让JVM抛出异常以确保遵守正确的同步约定。
代码示例
public static void main(String[] args) throws InterruptedException {Object object new Object();synchronized (object) {System.out.println(等待中);object.wait();System.out.println(等待结束);}
}这样在执行到object.wait()之后就一直等待下去那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了另外一个方法唤醒的方法notify()。
3.2 notify
notify 方法是唤醒等待的线程.
方法notify()也要在同步方法或同步块中调用该方法是用来通知那些可能等待该对象的对象锁的其它线程对其发出通知notify并使它们重新获取该对象的对象锁。
如果有多个线程等待则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”)
以下是notify方法的详细解释
notify方法是在Object类中定义的它用于唤醒等待在同一对象上的某个线程。当线程调用wait方法在对象上等待时它会释放对象的锁并进入等待状态。如果有其他线程调用了相同对象上的notify方法那么其中的一个线程无法确定具体是哪个线程会被唤醒并且开始竞争对象的锁。notify方法只会唤醒一个等待线程。如果有多个线程在等待状态不能确定哪个线程会被唤醒。唤醒的线程然后可以继续执行但是它需要重新获得对象的锁才能进入同步代码块或方法。如果没有线程在等待该对象的锁调用notify方法不会有任何影响。
下面是一个使用notify方法唤醒线程的简单Java代码示例
class MyThread extends Thread {private final Object lock;public MyThread(Object lock) {this.lock lock;}public void run() {synchronized (lock) {System.out.println(线程开始等待);try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(线程被唤醒);}}
}public class Main {public static void main(String[] args) throws InterruptedException {Object lock new Object();MyThread thread new MyThread(lock);synchronized (lock) {thread.start();Thread.sleep(2000); // 主线程休眠2秒钟模拟执行一些其他操作System.out.println(主线程执行notify操作);lock.notify();}}
}在上面的示例中我们创建了一个MyThread类继承自Thread类该线程在synchronized块中调用wait方法进行等待。在主线程中我们先让主线程休眠2秒钟然后调用notify方法来唤醒等待的线程。
当运行该程序时它会输出以下内容
线程开始等待
主线程执行notify操作
线程被唤醒可以看到等待的线程被成功唤醒并继续执行。请注意在使用notify方法前后需要通过synchronized关键字锁住共享对象。
notify方法只是唤醒某一个等待线程. 使用notifyAll方法可以一次唤醒所有的等待线程.
注意 notifyAll()方法是用于唤醒所有等待中的线程。它会将所有等待中的线程从等待状态转变为可执行状态。尽管被唤醒的线程数量可能是多个但在实际执行时这些线程仍然需要竞争锁对象的所有权。只有获取到锁对象的线程才能够执行而其他线程仍然需要等待。因此尽管被同时唤醒实际执行的先后顺序还是要根据线程竞争锁的情况来确定。
理解 notify 和 notifyAll
notify 只唤醒等待队列中的一个线程. 其他线程还是乖乖等着 notifyAll 一下全都唤醒, 需要这些线程重新竞争锁 3.3 wait 和 sleep 的对比
当涉及到多线程编程时我们经常会遇到wait和sleep这两个方法。尽管它们都可以暂停当前线程的执行但在功能和应用上存在一些异同点。下面是它们的详细解释 wait()方法 wait方法属于Object类在Java中所有对象都可调用该方法。调用wait方法会使线程进入等待状态直到其他线程调用同一对象上的notify或 notifyAll方法来唤醒等待线程。在调用wait方法之前线程必须获取对象的监视器锁即在同步块或同步方法中调用。线程在等待状态时会释放对象的监视器锁允许其他线程访问这个对象。wait方法可以通过以下方式被唤醒 其他线程调用了同一对象上的notify方法唤醒一个等待的线程其他线程调用了同一对象上的notifyAll方法唤醒所有等待的线程当前线程被中断调用了Thread.interrupt()方法。 sleep()方法 sleep方法属于Thread类可以直接在任何线程中调用。调用sleep方法不会释放锁或资源只是让线程休眠一段指定的时间然后线程继续执行。sleep方法传入一个时间参数以指定线程挂起的时间单位是毫秒或纳秒。在sleep期间线程不会释放锁或资源其他线程无法访问该线程持有的资源。sleep方法的唯一方法被打断休眠是通过线程中断调用了Thread.interrupt()方法。
综上所述主要的区别在于
wait方法是Object类的方法用于线程之间的同步和通信需要在同步块或同步方法中使用调用时会释放锁只能被唤醒或者中断才能继续执行sleep方法是Thread类的方法用于线程的暂停一段指定时间不会释放锁只能通过时间结束或被中断才能继续执行。
两者的使用场景和目的也不同需要根据具体需求来选择使用哪个方法。
