1.Atomic的原子自增运算

最好将thread.activeCount的值扩大一点儿，因为过小的话会导致内存切换的过于频繁，容易导致程序崩溃

运行结果如下：

代码源码：

import org.omg.PortableServer.THREAD_POLICY_ID;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Atomic变量自增运算测试
 */
public class AtomicTest {
    public static AtomicInteger race = new AtomicInteger(0);

    public static void increase() {
        race.incrementAndGet();
    }

    private static final int THREADS_COUNT = 20;


    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT]; //定义一组threas的数组集合
        for (int i = 0; i < THREADS_COUNT; i++) { //20个线程进行单个循环
            threads[i] = new Thread(new Runnable() {  //单个线程进行实现runable的操作
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++){
                        increase(); //对increase进行自增操作，执行结果如下,内部迭代的工程
                    }
                }
            });
            //启动当前状态的i线程，因此要写在for循环里面
            threads[i].start();
        }
        while(Thread.activeCount()>10);
        Thread.yield();
        System.out.println(race);//正确输出结果为10000（单个进程自增的次数）*20(总的进程数)
                                 //因此自增结果应该为200000,但是实际结果并不是，而是偏小
    }
}

先得出输出结果，如下；

代码如下：

import org.omg.PortableServer.THREAD_POLICY_ID;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Atomic变量自增运算测试
 */
public class AtomicTest {
    //public static AtomicInteger race = new AtomicInteger(0);
    public static int race = 1;
    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;


    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT]; //定义一组threas的数组集合
        for (int i = 0; i < THREADS_COUNT; i++) { //20个线程进行单个循环
            threads[i] = new Thread(new Runnable() {  //单个线程进行实现runable的操作
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++){
                        increase(); //对increase进行自增操作，执行结果如下,内部迭代的工程
                    }
                }
            });
            //启动当前状态的i线程，因此要写在for循环里面
            threads[i].start();
        }
        while(Thread.activeCount()>4);
        //Thread.yield();
        System.out.println(race);//正确输出结果为100（单个进程自增的次数）*20(总的进程数)
                                 //因此自增结果应该为2000,但是实际结果并不是，而是偏小
    }
}

//因此可知这种方法也是线程相对而言，并不是安全的。

但是AntomicInteger操作之后：

如下：

得出了正确的结果：

代码源码如下：

import org.omg.PortableServer.THREAD_POLICY_ID;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Atomic变量自增运算测试
 */
public class AtomicTest {
    public static AtomicInteger race = new AtomicInteger(0);
    public static void increase() {
        race.incrementAndGet();
    }

    private static final int THREADS_COUNT = 20;


    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT]; //定义一组threas的数组集合
        for (int i = 0; i < THREADS_COUNT; i++) { //20个线程进行单个循环
            threads[i] = new Thread(new Runnable() {  //单个线程进行实现runable的操作
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++){
                        increase(); //对increase进行自增操作，执行结果如下,内部迭代的工程
                    }
                }
            });
            //启动当前状态的i线程，因此要写在for循环里面
            threads[i].start();
        }
        while(Thread.activeCount()>2);
        //Thread.yield();
        System.out.println(race);//正确输出结果为100（单个进程自增的次数）*20(总的进程数)
                                 //因此自增结果应该为2000,但是实际结果并不是，而是偏小
    }
}

使用int进行定义的时候，race这是不安全的机制，详细代码，可以复制拿去验证，但是使用AtomicInteger尽享定义就不一样的了，因为其定义了race之后，调用方法,incrementAndGet（）方法，但是该方法是原子性的可以确保其线程是安全的。

验证的时候,Thread.activeCount>不要设置的过大。这个

问题会专门写个专题扩展一下：

Thread.activeCount() 方法返回活动线程的当前线程的线程组中的数量，已你现在的程序（线程中间过程短，一下就结束了）所以你Thread.activeCount()时为1，你可以System.out.println(Thread.activeCount())控制台输出试试

1的话，当前线程组的书，数目为1，是会导致切换过快，计算机进行假死的情况的。

因此需要设置成2以及以上即可。

其中incrementAndGet（）方法,跟进去，查看如下所示：

继承了Number类以及进行了序列化的操作：

final表明了这个是不可能轻易被继承的，一定程度保证了其原子性

然后再跟进一个getAndAddInt继续去跟进下一步：

对于getIntVolatile（）这个方法进行跟进如下所示；

扩展如下所示：

1。native 是用做java 和其他语言（如c++）进行协作时用的
也就是native 后的函数的实现不是用java写的
2。既然都不是java，那就别管它的源代码了

1.Atomic的原子自增运算

猜你喜欢