java concurrent并发包使用

package cn.com.zxf.atomic;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample implements Runnable{

    private AtomicInteger atomicInteger;

    private int index;

    public  AtomicExample(AtomicInteger atomicInteger, int index){

        this.atomicInteger=atomicInteger;

        this.index = index;
    }

    @Override
    public void run() {

        System.out.println("当前线程名称:"+Thread.currentThread().getName());

        atomicInteger.addAndGet(index);

    }
}

package cn.com.zxf.atomic;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AtomicExampleTest {

    //线程池
    private static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        //拦珊 使用
        CountDownLatch countDownLatch = new CountDownLatch(100);
        //信号量
        Semaphore semaphore = new Semaphore(3);
        //atomic 包使用 底层是基于CAS 并发编程
        final AtomicInteger atomicInteger = new AtomicInteger();
        //java 提供的锁
        Lock lock = new ReentrantLock();
        //队列
        LinkedBlockingDeque linkedBlockingDeque =  new LinkedBlockingDeque();
        for(int i = 0 ;i<100; i++){
            Thread.sleep(1000);
            semaphore.acquire();
            executorService.execute(new AtomicExample(atomicInteger,1));
            semaphore.release();

            Thread.sleep(1000);
            countDownLatch.countDown();
        }

       countDownLatch.await();

        executorService.shutdown();
        System.out.println("计算值："+atomicInteger.get());
    }
}

concurrent 使用