多线程concurrent包下的常用类

public class MyTest {
    @Test
    public void test1() {

        Semaphore semaphore = new Semaphore(2);
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        semaphore.release();

        CountDownLatch countDownLatch = new CountDownLatch(3);
        countDownLatch.countDown();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        CyclicBarrier barrier = new CyclicBarrier(3);
        try {
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }

        Lock lock = new ReentrantLock(true);
        lock = new ReentrantLock();
        lock.lock();
        lock.unlock();
        boolean b = lock.tryLock();
        try {
            boolean b1 = lock.tryLock(2, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        ReadWriteLock rwl = new ReentrantReadWriteLock(true);
        rwl = new ReentrantReadWriteLock();
        rwl.readLock().lock();
        rwl.readLock().unlock();
        boolean b2 = rwl.readLock().tryLock();
        try {
            boolean b3 = rwl.readLock().tryLock(2, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        rwl.writeLock().lock();
        rwl.writeLock().unlock();
        boolean b4 = rwl.writeLock().tryLock();
        try {
            boolean b5 = rwl.writeLock().tryLock(2, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //1支持公平和非公平的获取锁的方式;
        //2支持可重入。读线程在获取了读锁后还可以获取读锁，写线程在获取了写锁之后既可以再次获取写锁又可以获取读锁;
        //3还允许从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。但是，从读取锁升级到写入锁是不允许的;
        //4读取锁和写入锁都支持锁获取期间的中断。
        AtomicBoolean atomicBoolean = new AtomicBoolean(true);
        AtomicInteger atomicInteger = new AtomicInteger(5);
        AtomicLong atomicLong = new AtomicLong(5L);
        AtomicReference<String> atomicReference = new AtomicReference<>(new String());
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1);
        AtomicLongArray atomicLongArray = new AtomicLongArray(1);
        AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<>(1);
        AtomicIntegerFieldUpdater<String> atomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(String.class, "file");
        AtomicLongFieldUpdater<String> atomicLongFieldUpdater = AtomicLongFieldUpdater.newUpdater(String.class, "file");
        AtomicReferenceFieldUpdater<String, String> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(String.class, String.class, "file");
    }
}