CAS-手写自旋锁补充、thread.join()等待子线程执行完

package com.nanjing.gulimall.zhouyimo.test;

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author zhou
 * @version 1.0
 * @date 2023/12/28 10:06 下午
 */

public class SpinLock {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        Thread thread = Thread.currentThread();
        // 输出当前线程名称和获取锁的信息
        //System.out.println(Thread.currentThread().getName() + "获取锁"+"  ");
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    public void unLock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        // 输出当前线程名称和释放锁的信息
        //System.out.println(Thread.currentThread().getName() + "释放锁"+"  ");
    }

    private static int data = 0;
    public static void add() {
        for (int i = 0; i < 10000; i++) {
            data++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        /*for (int i = 0; i < 10; i++) {
                // 创建一个新的线程
                new Thread(() -> {
                // 创建一个自旋锁对象
                SpinLock spinLock = new SpinLock();注意这个锁必须要放在循环外面
                // 获取锁
                spinLock.lock();
                // 输出当前线程名称和获取锁的信息
                System.out.println(Thread.currentThread().getName() + "--获取锁--");
                add();
                // 阻塞当前线程5秒
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 释放锁
                spinLock.unLock();
                // 输出当前线程名称和释放锁的信息
                System.out.println(Thread.currentThread().getName() + "--释放锁--");
            }, "thread-" + i).start();
        }*/
        //上面代码不好实现所有线程执行完，打印data的值，改进
        int nums = 10;
        Thread[] threads = new Thread[nums];
        // 创建一个自旋锁对象
        SpinLock spinLock = new SpinLock();
        for (int i = 0; i < nums; i++) {
            Thread thread = new Thread(() -> {
                // 创建一个自旋锁对象
                //SpinLock spinLock = new SpinLock();注意这个锁必须要放在循环外面
                // 获取锁
                spinLock.lock();
                // 输出当前线程名称和获取锁的信息
                System.out.println(Thread.currentThread().getName() + "--获取锁--");
                add();
                // 阻塞当前线程5秒
                /*try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                // 释放锁
                spinLock.unLock();
                // 输出当前线程名称和释放锁的信息
                System.out.println(Thread.currentThread().getName() + "--释放锁--");
            },"线程"+i);
            thread.start();
            //注意这行代码要加上，不然会导致后面空指针
            threads[i] = thread;
        }

        Arrays.stream(threads).forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //打印data的值
        System.out.println("data="+data);

    }
}



线程0--获取锁--
线程0--释放锁--
线程1--获取锁--
线程1--释放锁--
线程7--获取锁--
线程7--释放锁--
线程4--获取锁--
线程4--释放锁--
线程6--获取锁--
线程6--释放锁--
线程9--获取锁--
线程9--释放锁--
线程3--获取锁--
线程3--释放锁--
线程2--获取锁--
线程2--释放锁--
线程5--获取锁--
线程5--释放锁--
线程8--获取锁--
线程8--释放锁--
data=100000

---

package com.nanjing.gulimall.zhouyimo.test;

import java.util.concurrent.atomic.AtomicInteger;

public class SpinLockNew {
    // 0 表示未上锁状态
    // 1 表示上锁状态
    protected AtomicInteger value;

    public SpinLockNew() {
        this.value = new AtomicInteger();
        // 设置 value 的初始值为0 表示未上锁的状态
        this.value.set(0);
    }

    public void lock() {
        // 进行自旋操作
        while (!value.compareAndSet(0, 1)) {
            ;
        }
    }

    public void unlock() {
        // 将锁的状态设置为未上锁状态
        value.compareAndSet(1, 0);
    }
}

package com.nanjing.gulimall.zhouyimo.test;

public class SpinLockTestNew {
    public static int data;
    public static SpinLock lock = new SpinLock();

    public static void add() {
        for (int i = 0; i < 10000; i++) {
            // 上锁 只能有一个线程执行 data++ 操作 其余线程都只能进行while循环
            lock.lock();
            data++;
            lock.unLock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100];
        // 设置100个线程
        for (int i = 0; i < 100; i ++) {
            //threads[i] = new Thread(SpinLockTestNew::add);
            //或者这样写
            threads[i] = new Thread(()->{
                for (int j = 0; j < 10000; j++) {
                    lock.lock();
                    // 输出当前线程名称和获取锁的信息
                    //System.out.println(Thread.currentThread().getName() + "--获取锁--");
                    data++;
                    lock.unLock();
                    // 输出当前线程名称和释放锁的信息
                    //System.out.println(Thread.currentThread().getName() + "--释放锁--");
                }
            });
            threads[i].setName("线程" + i);
        }
        // 启动一百个线程
        for (int i = 0; i < 100; i++) {
            threads[i].start();
        }
        // 等待这100个线程执行完成
        for (int i = 0; i < 100; i++) {
            threads[i].join();
        }
        System.out.println(data); // 10000000
    }
}

---

等待多个线程执行完成后再运行的几种方式 

等待多个线程执行完成后再运行的几种方式_java等待线程池多个任务结束-CSDN博客

面试官：如何让主线程等待所有的子线程执行结束之后再执行_主线程等待其他线程完成后再执行-CSDN博客