自旋锁的伪代码实现，CAS的ABA问题，JUC常见类：Callable,ReentrantLock,线程创建方法的总结，信号量，原子类的应用场景，特定场所的组件CountDomLatch,针对集合类的

//伪代码哈，不是真实的
 class  SpinLock{
//此处使用owner表示当前是哪个线程持有的这把锁，null解锁状态
        private Thread owner=null;
        public void lock(){
            while(!CAS(this.owner,null,Thread.currentThread())){
//Thread.currentThread()，这个是用来获取当前哪个线程调用lock，得到结果就是哪个线程的引用，如果当前锁已经处于加锁状态，这里就会返回false，cas不会进行实际操作，继续进行下一个循环
            }
        }

  Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i=1;i< 100;i++) {
                    sum += i;
                }
                return sum;
            }
        };
//Callable不能作为Thread的构造方法参数，所以一般用下面这种操作
        FutureTask<Integer>futureTask=new FutureTask<>(callable);
//通过这样来作为Thread的参数
        Thread t=new Thread(futureTask);
        t.start();
        Integer result= futureTask.get();
//get方法类似于join一样，
        System.out.println(result);
    }
}

import java.util.concurrent.locks.ReentrantLock;
class Count {
    public int count = 0;
     public void increase() {
        count++;
    }
}
    public class Demo8 {
            public static void main(String[] args) throws InterruptedException {
                Count counter = new Count();
                ReentrantLock locker=new ReentrantLock();
                Thread t1 = new Thread(() -> {
                    locker.lock();
                    for (int i = 0; i < 5000; i++) {
                        counter.increase();
                    }
                    locker.unlock();
                });
                Thread t2 = new Thread(() -> {
                    ReentrantLock lock=new ReentrantLock();
                    locker.lock();          //加锁
                    for (int i = 0; i < 5000; i++) {
                        counter.increase();
                    }
                    locker.unlock();        //关锁
                });
                t1.start();
                t2.start();
                t1.join();       //等待t1执行完毕，之前上一个没写join,但是就算写他也是错的
                t2.join();       //等待t2执行完毕，最后main线程
                System.out.println(counter.count);
            }
        }

import java.util.concurrent.Semaphore;
public class Demo9 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore=new Semaphore(4);
        semaphore.acquire();
        System.out.println("计数器-1");
        semaphore.acquire();
        System.out.println("计数器-1");
        semaphore.acquire();
        System.out.println("计数器-1");
        semaphore.acquire();
        System.out.println("计数器-1");
//这里线程就不够用了，会进行阻塞等待
        semaphore.release();
        semaphore.acquire();
        System.out.println("我喜欢你");
    }
}

import java.util.concurrent.CountDownLatch;
public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            int id = i;
            Thread t = new Thread(() -> {
//这里涉及变量捕获，java获取这个变量，但是final或者事实上final的变量(因为进行了++，改进）
                System.out.println("线程" + id+ "开始工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程" + id+ "完成工作");
                //这里输入的是id,因为输入i会报错，i是局部变量
            countDownLatch.countDown();});
              t.start();}
//countDownLatch.await()负责等待任务结束,a->all等待全部任务结束，
        countDownLatch.await();
        System.out.println("全部完成了");
        }
    }

import java.util.concurrent.CountDownLatch;
//当调用countDown次数<初始化设置的次数await就会阻塞等待 
public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);          //10个加载器
        for (int i = 0; i < 5; i++) {
            int id = i;
            Thread t = new Thread(() -> {
//这里涉及变量捕获，java获取这个变量，但是final或者事实上final的变量(因为进行了++，改进）
                System.out.println("线程" + id+ "开始工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程" + id+ "完成工作");
                //这里输入的是id,因为输入i会报错，i是局部变量
            countDownLatch.countDown();});
              t.start();}
//countDownLatch.await()负责等待任务结束,a->all等待全部任务结束，当调用countDown次数<初始化设置的次数await就会阻塞等待
//这时候我只是调用了5次，总共初始化是10次，所以线程会进行阻塞等待
        countDownLatch.await();
        System.out.println("全部完成了");
        }
    }