@Test
void testRunnable() {
    ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 100, 200, TimeUnit.MINUTES, new LinkedBlockingDeque<>());
    executor.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("aaa");
        }
    });
}

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);
}

executor.shutdown();
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改线程状态为SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 将队列中的任务执行完毕
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 调用尝试关闭方法
    tryTerminate();
}

executor.shutdownNow();
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改进程状态
        advanceRunState(STOP);
        // 中断执行操作
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // isRunning(c)：判断线程池是否正在运行
    	// runStateAtLeast(c, TIDYING)：判断线程池状态是否至少为 TIDYING
    	// runStateLessThan(c, STOP) && ! workQueue.isEmpty()：判断线程池状态小于 STOP 且工作队列不为空
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
            return;
        // 如果工作线程数量不为 0
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 将线程池状态改为TIDYING状态
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    // 执行终结操作
                    terminated();
                } finally {
                    // 将线程池状态转换成TERMINATED状态
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

private static final Object lock = new Object();

@Test
void testStopThread() throws InterruptedException {
    Thread thread = new Thread(() -> {
        synchronized (lock) {
            for (int i = 0; i < 100; i++) {
                System.out.println(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    });

    // 启动线程
    thread.start();

    Thread.sleep(3000);

    // 终止线程
    thread.stop();

    // 判断线程中的锁是否释放
    synchronized (lock) {
        System.out.println("该锁已经解开");
    }

}

0
1
2
该锁已经解开

@Test
void testStopThread() throws InterruptedException {
    ReentrantLock reentrantLock = new ReentrantLock();
    Thread thread = new Thread(() -> {
        reentrantLock.lock();
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        reentrantLock.unlock();
    });

    // 启动线程
    thread.start();

    Thread.sleep(3000);

    // 终止线程
    thread.stop();

    // 判断线程中的锁是否释放
    reentrantLock.lock();
    System.out.println("该锁已经解开");
    reentrantLock.unlock();

}

0
1
2

@Test
void testStopThread() throws InterruptedException {
    Thread thread = new Thread(() -> {
        for (int i = 0; i < 1000000; i++) {
            if (Thread.currentThread().isInterrupted()) {
                // 判断如果外部需要本线程停止的话，线程在做下一步操作
                if (i > 300000) break; // 如果输出的i大于300000则可以终止，则直接终止操作
            }
            System.out.println(i);
        }
    });

    // 启动线程
    thread.start();

    Thread.sleep(1000);

    // 终止线程
    thread.interrupt();

    System.out.println("结束操作");

}

...
287223
287224
结束操作
287225
287226
...
300000

private static int counter = 0;
@Test
void testAtom() throws InterruptedException {
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter++;
        }
    });
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter++;
        }
    });

    // 启动两个线程
    thread1.start();
    thread2.start();
    // 等待两个线程执行完毕
    thread1.join();
    thread2.join();
    // 输出最终结果
    System.out.println("最终变量值: " + counter);
}

最终变量值: 1509

private final static Object lock2 = new Object();
@Test
void testAtom() throws InterruptedException {
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            synchronized (lock2) {
                counter++;
            }
        }
    });
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            synchronized (lock2) {
                counter++;
            }
        }
    });

    // 启动两个线程
    thread1.start();
    thread2.start();
    // 等待两个线程执行完毕
    thread1.join();
    thread2.join();
    // 输出最终结果
    System.out.println("最终变量值: " + counter);
}

最终变量值: 2000

public class Person() {
    static Person instance;
    
    public Person getInstance() {
        if (instance == null){
            synchronized(Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
    }
}

public class Person() {
    static volatile Person instance;
    
    public Person getInstance() {
        if (instance == null){
            synchronized(Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
    }
}

public class Person() {
    static Person instance;
    
    public synchronized Person getInstance() {
        if (instance == null){
            synchronized(Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
    }
}

public class Person() {
    static Person instance;
   
    private final Lock lock = new ReentrantLock();
    
    public Person getInstance() {
        lock.lock();
        if (instance == null){
            synchronized(Person.class) {
                if (instance == null) {
                    instance = new Person();
                }
            }
        }
        lock.unlock();
    }
}

class Resource {
    // 资源类
}

public class OrderLockExample {
    private static final Resource resource1 = new Resource();
    private static final Resource resource2 = new Resource();

    public static void main(String[] args) {
        // 线程 1 按顺序获取锁
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) { // 加锁A
                System.out.println("Thread 1 acquired resource1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {  // 加锁B
                    System.out.println("Thread 1 acquired resource2");
                }
            }
        });

        // 线程 2 按相同顺序获取锁
        Thread thread2 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 2 acquired resource1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 2 acquired resource2");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class TimeoutLockExample {
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock(1, TimeUnit.SECONDS)) { //加锁A，设置超时时间 一秒
                    System.out.println("Thread 1 acquired lock1");
                    try {
                        if (lock2.tryLock(1, TimeUnit.SECONDS)) { // 加锁B，设置超时时间一秒
                            System.out.println("Thread 1 acquired lock2");
                            // 执行操作
                            lock2.unlock();
                        }
                    } finally {
                        lock1.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
		// 线程2和线程1加锁的顺序一样
        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock(1, TimeUnit.SECONDS)) {
                    System.out.println("Thread 2 acquired lock2");
                    try {
                        if (lock1.tryLock(1, TimeUnit.SECONDS)) {
                            System.out.println("Thread 2 acquired lock1");
                            // 执行操作
                            lock1.unlock();
                        }
                    } finally {
                        lock2.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }
}

public class ReduceLockHoldTimeExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 不需要加锁的代码
            System.out.println("Do some work without lock");

            synchronized (lock) {
                // 需要加锁的代码
                System.out.println("Acquired lock");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Released lock");
            }

            // 不需要加锁的代码
            System.out.println("Do some more work without lock");
        });

        thread.start();
    }
}

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class DeadlockDetectionExample {
    public static void main(String[] args) {
        // 初始化ThreadMxBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 获取所有的锁
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        if (deadlockedThreads != null) {
            // threadMxBean通过getThreadInfo来判断是否有死锁
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreads);
            for (ThreadInfo threadInfo : threadInfos) {
                System.out.println("Deadlocked thread: " + threadInfo.getThreadName());
            }
        }
    }
}

public class SharedVariableCommunication {
    // 使用volatile关键字保证变量的可见性
    private static volatile int sharedData = 0;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            // 对共享变量进行写操作
            sharedData = 10;
        });

        Thread thread2 = new Thread(() -> {
            // 读取共享变量的值
            System.out.println("Shared data value: " + sharedData);
        });

        thread1.start();
        thread2.start();
    }
}

public class ThreadCommunication {
    private static final Object lock = new Object();
    private static int data;

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            synchronized (lock) {
                data = 42;
                // 通知消费者线程数据已准备好
                lock.notify();
            }
        });

        Thread consumer = new Thread(() -> {
            synchronized (lock) {
                while (data == 0) {
                    try {
                        // 等待生产者线程通知
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("Consumed data: " + data);
            }
        });

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureCommunication {
    public static void main(String[] args) throws Exception {
        // 创建一个线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 创建一个Callable任务
        java.util.concurrent.Callable<Integer> callable = () -> {
            // 模拟耗时操作
            Thread.sleep(2000);
            return 42;
        };

        // 提交任务并获取Future对象
        Future<Integer> future = executor.submit(callable);

        // 获取任务的执行结果
        System.out.println("Result: " + future.get());

        // 关闭线程池
        executor.shutdown();
    }
}