多线程测试

import cn.hutool.core.thread.lock.LockUtil;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @date 2022/7/15 13:55
 * @since : JDK 11
 */
public class Test {

    private static CountDownLatch countDownLatch = new CountDownLatch(2);


    public static void main(String[] args) {
    }

    private static Integer sum = 0;


    /**
     * 线程阶段器
     */
    public static void T2() {
        CyclicBarrier c = new CyclicBarrier(2, () -> System.out.println("我会先跑5秒，不管你信不信！"));
        new Thread(() -> {
            try {
                c.await();
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "正在等待...");

        }, "线程name").start();
        try {
            c.await();
        } catch (Exception e) {
        }
        System.out.println(Thread.currentThread().getName() + "正在等待...");
        System.out.println("人够了，出发吧 当前有 " + c.getParties() + " 个人参与比赛");
    }


    /**
     * 线程暂停
     */
    public static void T1() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("正在执行!!!");
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("接收到外部停止线程信号");
                    break;
                }
            }
        });
        t1.start();

        Thread.sleep(1000 * 10);

        t1.interrupt();

    }


    /**
     * 死锁
     */
    public static void deadLock() throws InterruptedException {
        ReentrantReadWriteLock lockA = LockUtil.createReadWriteLock(true);
        ReentrantReadWriteLock lockB = LockUtil.createReadWriteLock(true);
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                lockA.writeLock().lock();
                sum++;
                System.out.println("A :" + i);
                lockB.writeLock().lock();
                lockA.writeLock().unlock();
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                lockB.writeLock().lock();
                sum++;
                System.out.println("B :" + i);
                lockA.writeLock().lock();
                lockB.writeLock().unlock();
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("汇总：" + sum);
    }


    /**
     * 不安全的例子
     */
    public static void notSafe() throws InterruptedException {
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                sum++;
                System.out.println("A :" + i);
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                sum++;
                System.out.println("B :" + i);
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("汇总：" + sum);
    }

    /**
     * 使用synchronized保持线程安全
     */
    public static void TestSynchronized() throws InterruptedException {
        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (sum) {
                    sum++;
                }
                System.out.println("A :" + i);
            }
            countDownLatch.countDown();
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (sum) {
                    sum++;
                }
                System.out.println("B :" + i);
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("汇总：" + sum);
    }

    /**
     * 读写锁保持线程安全
     */
    public static void TestReentrantReadWriteLock() throws InterruptedException {
        // 读写锁
        // 写锁：互斥锁(读锁、写锁都互斥)
        // 读锁：共享锁(只对读锁共享，多个线程都可以去读并且不会阻塞)
        // 线程拿到写锁的时候，其它线程阻塞等待写锁释放才能继续操作，不会产生并发问题
        // 线程拿到读锁的时候，若其它线程也是读锁，则操作变量时会产生并发问题，若其它线程是写锁，则不会产生并发问题
        ReentrantReadWriteLock lock = LockUtil.createReadWriteLock(true);
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                lock.readLock().lock();
                sum++;
                System.out.println("A :" + i);
                lock.readLock().unlock();
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                lock.writeLock().lock();
                sum++;
                System.out.println("B :" + i);
                lock.writeLock().unlock();
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("汇总：" + sum);
    }


    private static AtomicInteger sum1 = new AtomicInteger(0);

    /**
     * 使用原子类保持线程安全
     */
    public static void TestAtomicInteger() throws InterruptedException {
        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                sum1.incrementAndGet();
                System.out.println("A :" + i);
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                sum1.incrementAndGet();
                System.out.println("B :" + i);
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("汇总：" + sum1.get());
    }
}