常见的并发原因和解决方法 #

//定义两个对象锁
private static Object lockA = new Object();
private static Object lockB = new Object();

//线程1
public void thread1() {
    synchronized (lockA) { //先获取锁A
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lockB) { //再获取锁B
            System.out.println("thread1");
        }
    }
}

//线程2
public void thread2() {
    synchronized (lockA) { //先获取锁A
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lockB) { //再获取锁B
            System.out.println("thread2");
        }
    }
}

//定义一个任务
public class Task implements Runnable {
    private String name;
    private Random random = new Random();

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while (true) {
            //检测是否有其他线程正在执行任务
            if (Thread.interrupted()) {
                System.out.println(name + "发现对方正在执行任务，谦让一下");
                //等待一个随机的时间再重试
                try {
                    Thread.sleep(random.nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println(name + "开始执行任务");
                //中断另一个线程
                Thread.currentThread().getThreadGroup().interrupt();
            }
        }
    }
}

//创建两个线程分别执行任务
public class Test {

    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("group");
        Thread t1 = new Thread(group, new Task("t1"));
        Thread t2 = new Thread(group, new Task("t2"));
        t1.start();
        t2.start();
    }
}

//定义一个接口调用方法
public class Service {
    private Random random = new Random();

    public void call() throws Exception {
        //模拟一定概率的失败
        if (random.nextInt(10) < 8) {
            throw new Exception("调用失败");
        } else {
            System.out.println("调用成功");
        }
    }
}

//定义一个重试机制类
public class Retryer {
    private int maxAttempts; //最大重试次数
    private long interval; //初始间隔时间
    private double multiplier; //间隔时间增长因子

    public Retryer(int maxAttempts, long interval, double multiplier) {
        this.maxAttempts = maxAttempts;
        this.interval = interval;
        this.multiplier = multiplier;
    }

    //执行一个任务，并在失败时进行重试
    public void execute(Runnable task) throws Exception {
        int attempts = 0; //当前尝试次数
        long waitTime = interval; //当前等待时间
        while (true) {
            try {
                task.run(); //执行任务
                break; //成功则退出循环
            } catch (Exception e) { //捕获异常
                attempts++; //尝试次数加一
                if (attempts >= maxAttempts) { //达到最大尝试次数则抛出异常
                    throw new Exception("超过最大重试次数", e);
                } else { //否则等待一段时间再重试，并更新等待时间
                    System.out.println("第" + attempts + "次调用失败，等待" + waitTime + "毫秒后重试");
                    Thread.sleep(waitTime);
                    waitTime *= multiplier;
                }
            }
        }
    }
}

//创建一个服务对象和一个重试器对象，并执行任务
public class Test {

    public static void main(String[] args) throws Exception {
        Service service = new Service();
        Retryer retryer = new Retryer(5, 3000, 2);
        retryer.execute(() -> service.call());
    }
}
方案优点:
- 这种方法的优点是可以提高业务的可用性、容错性和一致性，可以有效地避免活锁的发生，可以适应不同的场景和需求。

//定义一个接口调用方法
public class Service {
    private Random random = new Random();

    public void call() throws Exception {
        //模拟一定概率的失败
        if (random.nextInt(10) < 8) {
            throw new Exception("调用失败");
        } else {
            System.out.println("调用成功");
        }
    }
}

//定义一个重试机制类
public class Retryer {
    private int maxAttempts; //最大重试次数

    public Retryer(int maxAttempts) {
        this.maxAttempts = maxAttempts;
    }

    //执行一个任务，并在失败时进行重试
    public void execute(Runnable task) throws Exception {
        int attempts = 0; //当前尝试次数
        while (true) {
            try {
                task.run(); //执行任务
                break; //成功则退出循环
            } catch (Exception e) { //捕获异常
                attempts++; //尝试次数加一
                if (attempts >= maxAttempts) { //达到最大尝试次数则抛出异常
                    throw new Exception("超过最大重试次数", e);
                } else { //否则打印日志并继续重试
                    System.out.println("第" + attempts + "次调用失败，继续重试");
                }
            }
        }
    }
}

//创建一个服务对象和一个重试器对象，并执行任务
public class Test {

    public static void main(String[] args) throws Exception {
        Service service = new Service();
        Retryer retryer = new Retryer(5);
        retryer.execute(() -> service.call());
    }
}

//定义一个共享资源类
public class Resource {
    private int value; //资源值

    public Resource(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

//定义一个任务类，实现Runnable接口
public class Task implements Runnable {
    private Resource resource; //共享资源对象
    private ReentrantLock lock; //公平锁对象

    public Task(Resource resource, ReentrantLock lock) {
        this.resource = resource;
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            lock.lock(); //请求锁
            System.out.println(Thread.currentThread().getName() + "获取了锁");
            //模拟对资源的操作
            int value = resource.getValue();
            Thread.sleep(1000); //模拟耗时操作
            resource.setValue(value + 1);
            System.out.println(Thread.currentThread().getName() + "修改了资源值为" + resource.getValue());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //释放锁
            System.out.println(Thread.currentThread().getName() + "释放了锁");
        }
    }
}

//创建一个公平锁对象和一个共享资源对象，并启动多个线程执行任务
public class Test {

    public static void main(String[] args) throws Exception {
        ReentrantLock lock = new ReentrantLock(true); //创建一个公平锁对象，设置fair参数为true
        Resource resource = new Resource(0); //创建一个共享资源对象，初始值为0

        for (int i = 0; i < 5; i++) { //启动5个线程执行任务
            Task task = new Task(resource, lock); //创建一个任务对象
            Thread thread = new Thread(task, "Thread-" + i); //创建一个线程对象，并命名为Thread-i
            thread.start(); //启动线程
        }
    }
}

import java.util.concurrent.atomic.AtomicMarkableReference;

public class AtomicMarkableReferenceDemo {

    // 创建一个AtomicMarkableReference对象，初始引用值为"abc"，初始标记值为false
    private static AtomicMarkableReference<String> amr = new AtomicMarkableReference<>("abc", false);

    public static void main(String[] args) {
        // 创建两个线程，分别尝试修改引用值和标记值
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 获取当前的引用值和标记值
                String s = amr.getReference();
                boolean b = amr.isMarked();
                System.out.println("线程1获取的引用值：" + s + "，标记值：" + b);
                // 模拟耗时操作
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 尝试将引用值从"abc"改为"def"，标记值从false改为true
                boolean result = amr.compareAndSet(s, "def", b, true);
                System.out.println("线程1修改结果：" + result);
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 获取当前的引用值和标记值
                String s = amr.getReference();
                boolean b = amr.isMarked();
                System.out.println("线程2获取的引用值：" + s + "，标记值：" + b);
                // 尝试将引用值从"abc"改为"ghi"，标记值从false改为true
                boolean result = amr.compareAndSet(s, "ghi", b, true);
                System.out.println("线程2修改结果：" + result);
            }
        });

        // 启动两个线程
        t1.start();
        t2.start();

        // 等待两个线程结束
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出最终的引用值和标记值
        System.out.println("最终的引用值：" + amr.getReference() + "，标记值：" + amr.isMarked());
    }
}

//创建一个初始引用为null，初始戳记为0的AtomicStampedReference
String initialRef = null;
int initialStamp = 0;
AtomicStampedReference<String> atomicStampedReference = new AtomicStampedReference<String>(initialRef, initialStamp);

//获取引用和戳记
String reference = atomicStampedReference.getReference();
int stamp = atomicStampedReference.getStamp();

//设置新的引用和戳记
String newRef = "some value";
int newStamp = stamp + 1;
atomicStampedReference.set(newRef, newStamp);

//比较并设置新的引用和戳记，如果当前引用和戳记与期望值相同
String expectedRef = "some value";
int expectedStamp = 1;
String updatedRef = "new value";
int updatedStamp = expectedStamp + 1;
boolean wasUpdated = atomicStampedReference.compareAndSet(expectedRef, updatedRef, expectedStamp, updatedStamp);