Java-JUC（十三）：如今有两个线程同时操做一个整数I，作自增操做，如何实现I的线程安全性？

问题分析：正如i在多线程中若是想实现i的多线程操做，必须i要使用volitle来保证其内存可见性，可是i++自增操做不具有原子性操做，所以须要对i++这段代码确保其原子性操做便可。

方案1：

使用ReetranLock实现i++的原子性操做。

private static volatile int i=0;
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(2);
        Lock lock=new ReentrantLock();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    lock.lock();
                    i++;
                }finally{
                    lock.unlock();
                    countDownLatch.countDown();
                }
            }
        },"Thread-1");
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    lock.lock();
                    i++;
                }finally{
                    lock.unlock();
                    countDownLatch.countDown();
                }
            }
        },"Thread-2");
        thread1.start();
        thread2.start();
        countDownLatch.await();

        System.out.println(i);
    }

方案2：

使用Semaphore实现i++的原子性操做。

private static volatile int i = 0;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Semaphore semaphore = new Semaphore(1);
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                i++;
                semaphore.release();
                countDownLatch.countDown();
            }
        }, "Thread-1");
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                i++;
                semaphore.release();
                countDownLatch.countDown();
            }
        }, "Thread-2");
        thread1.start();
        thread2.start();
        countDownLatch.await();

        System.out.println(i);
    }

 固然也能够选择sychronized方式实现。