1.并发安全问题
什么叫线程安全性：
我们可以这么理解，我们所写的代码在并发情况下使用时，总是能表现出正确的行为；反之，未实现线程安全的代码，表现的行为是不可预知的，有可能正确，而绝大多数的情况下是错误的。
如何确保类是线程安全的：
1>可以实现线程封闭，就是把对象封装到一个线程中，只有这一个线程能看到这个对象，比如之前所说的ThreadLocal;还有就是可以实现栈封闭，就是将共享资源存在线程的局部变量中，这样每个线程都有自己独立的拷贝，不会被其它线程访问；还可以用局部变量（少用全局变量），在方法内部创建局部变量，不暴露出去，和返回值void差不多的意思。
2>使用无状态类：无状态类（Stateless Class）是指类的实例不包含任何持久状态或数据，它的行为仅由传入的参数决定，不依赖于外部状态或上下文。无状态类的每个方法调用都可以视为一个独立的操作，不会受到之前方法调用的影响，因此无状态类在多线程环境中更容易实现线程安全性，举个栗子：
public class StatelessCalculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
// 其他方法...
}
在这个例子中，StatelessCalculator 类没有任何实例变量，所有的方法都是根据传入的参数执行计算操作，不依赖于任何外部状态。每次方法调用都是独立的，不会影响其他方法调用的结果，因此这个类可以被视为无状态类。
3>让类不可变(final)，加锁和CAS等......
死锁：
死锁（Deadlock）是指在多线程编程中，两个或多个线程因争夺资源而发生相互等待的一种情况，导致程序无法继续执行下去，进入一种僵持状态。在死锁中，每个线程都在等待某个资源被释放，而同时又持有其他线程需要的资源，从而形成一个闭环，导致所有参与的线程都无法继续执行。
public class DeadlockExample {
public static void main(String[] args) {
final Object resource1 = new Object();
final Object resource2 = new Object();
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: Holding resource 1...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for resource 2...");
synchronized (resource2) {
System.out.println("Thread 1: Acquired resource 2!");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (resource2) {
System.out.println("Thread 2: Holding resource 2...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2: Waiting for resource 1...");
synchronized (resource1) {
System.out.println("Thread 2: Acquired resource 1!");
}
}
});
thread1.start();
thread2.start();
}
}
在这个例子中，两个线程分别持有 resource1 和 resource2 锁，并尝试获取对方持有的锁。由于线程之间相互等待对方释放锁，最终导致死锁的发生。这是一个典型的死锁示例，实际开发中应该避免这种情况的发生。
解决方法：
1>定位死锁，jps + jstack pid 迅速定位死锁位置；
2>优化代码：内部通过顺序比较，确定拿锁的顺序； 采用尝试拿锁的机制（顺序不一致）。
public class DeadlockAvoidanceExample {
public static void main(String[] args) {
final Object resource1 = new Object();
final Object resource2 = new Object();
Thread thread1 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 1: Holding resource 1...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for resource 2...");
synchronized (resource2) {
System.out.println("Thread 1: Acquired resource 2!");
}
}
});
Thread thread2 = new Thread(() -> {
synchronized (resource1) {
System.out.println("Thread 2: Holding resource 1...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2: Waiting for resource 2...");
synchronized (resource2) {
System.out.println("Thread 2: Acquired resource 2!");
}
}
});
thread1.start();
thread2.start();
}
}
在这个例子中，为了避免死锁，我们规定线程必须按照一定的顺序获取锁。在 thread1 和 thread2 中，两个线程都先获取 resource1 锁，然后再获取 resource2 锁。这样做可以避免死锁，因为两个线程都按照相同的顺序获取锁，不会出现循环等待的情况。这是一种简单的死锁避免方法，但在复杂的场景下可能需要更复杂的策略来避免死锁，比如通过对象的hash值排序等方法。
import java.util.concurrent.locks.ReentrantLock;
public class DeadlockAvoidanceWithReentrantLockExample {
public static void main(String[] args) {
ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();
Thread thread1 = new Thread(() -> {
lock1.lock();
System.out.println("Thread 1: Holding lock 1...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 1: Waiting for lock 2...");
lock2.lock();
System.out.println("Thread 1: Acquired lock 2!");
lock2.unlock();
lock1.unlock();
});
Thread thread2 = new Thread(() -> {
lock1.lock();
System.out.println("Thread 2: Holding lock 1...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2: Waiting for lock 2...");
lock2.lock();
System.out.println("Thread 2: Acquired lock 2!");
lock2.unlock();
lock1.unlock();
});
thread1.start();
thread2.start();
}
}
在这个例子中，我们使用了可重入锁 ReentrantLock 来避免死锁。ReentrantLock 具有可重入性，同一个线程可以多次获取同一个锁，而不会出现死锁。因此，线程1和线程2都可以先获取 lock1，然后获取 lock2，确保了资源的有序获取和释放。这样的设计可以有效地避免死锁的发生。
活锁：
两个线程在尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生同一个线程总是拿到同一把锁，在尝试拿另一把锁时因为拿不到，而将本来已经持有的锁释放的过程
解决方法：
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
*类说明：演示普通账户的死锁和解决 以及 活锁的问题
*/
public class TryLock {
private static Lock No13 = new ReentrantLock();//第一个锁
private static Lock No14 = new ReentrantLock();//第二个锁
//先尝试拿No13 锁，再尝试拿No14锁，No14锁没拿到，连同No13 锁一起释放掉
private static void task1() throws InterruptedException {
String threadName = Thread.currentThread().getName();
Random r = new Random();
while(true){
if(No13.tryLock()){
System.out.println(threadName +" get 13");
try{
if(No14.tryLock()){
try{
System.out.println(threadName +" get 14");
System.out.println("task1 do work------------");
break;
}finally{
No14.unlock();
}
}
}finally {
No13.unlock();
}
}
Thread.sleep(r.nextInt(3));//解决活锁问题 注释掉会产生多次循环
}
}
//先尝试拿No14锁，再尝试拿No13锁，No13锁没拿到，连同No14锁一起释放掉
private static void task2() throws InterruptedException {
String threadName = Thread.currentThread().getName();
Random r = new Random();
while(true){
if(No14.tryLock()){
System.out.println(threadName +" get 14");
try{
if(No13.tryLock()){
try{
System.out.println(threadName +" get 13");
System.out.println("task2 do work------------");
break;
}finally{
No13.unlock();
}
}
}finally {
No14.unlock();
}
}
Thread.sleep(r.nextInt(3));//解决活锁问题
}
}
public static void main(String[] args) {
new Thread(()->{
try {
task1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
try {
task2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
1460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
