多线程之Semaphore和Atomiclnteger关键字

多线程之Semaphore和Atomiclnteger关键字

Semaphore：

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目

ASemaphore：

package com.liu.demo08;

import java.util.concurrent.Semaphore;

/**
 * @outhor liu
 * @dare 2020/7/9 23:23
 */
public class ASemaphore {
    public static void main(String[] args) {
        //创建可同时访问的线程数
        Semaphore semaphore = new Semaphore(3);
        try {
            //申请许可
            semaphore.acquire();
            //业务逻辑
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //释放许可
            semaphore.release();
        }
    }
}

Atomiclnteger的使用场景
AtomicInteger提供原子操作来进行Integer的使用，适合并发情况下的使用，比如两个线程对同一个整数累加。

Atomiclnteger是线程安全的，原理是什么
AtomicInteger是对int类型的一个封装，提供原子性的访问和更新操作，其原子性操作的实现是基于CAS（compare-and-swap）技术。CAS表现为一组指令，当利用CAS执行试图进行一些更新操作时，会首先比较当前数值，如果数值未变，代表没有其它线程进行并发修改，则成功更新。如果数值改变，则可能出现不同的选择，要么进行重试，要么就返回是否成功。也就是所谓的“乐观锁”。

Atomiclnteger的CAS机制会导致什么问题
会导致ABA问题，操作对象，获取对象后，执行CAS操作前，被其他线程修改后，且又修改为原来的对象值，导致CAS忽略其他线程的修改，成功执行CAS对象修改。

BAtomiclnteger：

package com.liu.demo08;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @outhor liu
 * @dare 2020/7/9 23:27
 */
public class BAtomiclnteger implements Runnable{

    //定义原子操作类
    static AtomicInteger atomicInteger = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i = 0; i <10000 ; i++) {
            atomicInteger.getAndIncrement();
        }
    }

}

AtomiclntegerDemoTest：

package com.liu.demo08;

/**
 * @outhor liu
 * @dare 2020/7/9 23:31
 */
public class AtomiclntegerDemoTest {
    public static void main(String[] args) throws InterruptedException {
        BAtomiclnteger bAtomiclnteger = new BAtomiclnteger();
        Thread t1 = new Thread(bAtomiclnteger);
        Thread t2 = new Thread(bAtomiclnteger);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        System.out.println(bAtomiclnteger.atomicInteger.get());
    }
}

输出

20000