多线程基础讲解八： JDK1.5提供的并发包（API）

java.util.concurrent.atomic包

Classes

• AtomicBoolean
• AtomicInteger       比如这个，就是对int类型数据原子性操作的工具类。
• AtomicIntegerArray
• AtomicIntegerFieldUpdater
• AtomicLong
• AtomicLongArray
• AtomicLongFieldUpdater
• AtomicMarkableReference
• AtomicReference
• AtomicReferenceArray
• AtomicReferenceFieldUpdater
• AtomicStampedReference
• DoubleAccumulator
• DoubleAdder
• LongAccumulator
• LongAdder

 

现在就来展示一下，使用这个工具类  和    不使用的效果。

 

首先不使用jdk1.5提供的原子性操作工具类：

public class StaticThread extends Thread {

    /**
     * 加static修饰的全局变量，数据才能被共享
     */
    private static int count = 0;

    @Override
    public void run() {

        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println(getName() + " count值为：" + count);
    }
}

public class Test {

    public static void main(String[] args) {

        /**
         * 创建10个线程
         */
        StaticThread[] staticThread = new StaticThread[10];
        for (int i = 0; i < staticThread.length; i++) {
            staticThread[i] = new StaticThread();
        }

        /**
         * 启动10个线程
         */
        for (StaticThread thread : staticThread) {
            thread.start();
        }

        /**
         * 打印结果：
         *    Thread-1 count值为：2228
         *    Thread-5 count值为：6000
         *    Thread-4 count值为：5000
         *    Thread-0 count值为：2000
         *    Thread-8 count值为：8907
         *    Thread-2 count值为：3000
         *    Thread-3 count值为：4000
         *    Thread-9 count值为：9907
         *    Thread-7 count值为：7907
         *    Thread-6 count值为：7219
         *
         * 加上了static之后，数据是增量的。
         *
         * 为什么 ？
         *
         * 因为静态变量，存在的内存区域，数据会被共享。 既然会被共享，如果不做线程安全的特殊处理，那就一定有线程安全问题。
         * 
         * 所以，数据虽然是增量的，但是相加的结果有几率没有10000的正确结果。
         */
    }
}

 

 

使用jdk1.5提供的工具类:

public class UseConcurrentUtilsThread extends Thread {

    /**
     * 使用jdk1.5提供的并发包的对int数据操作的类，代替 private int count = 0;
     * <p>
     * 注意这里一定要加 static，因为被static修饰的数据才能被共享。
     */
    private static AtomicInteger atomicInteger = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            /**
             * 使用incrementAndGet()方法代替 count++;
             */
            atomicInteger.incrementAndGet();
        }

        /**
         * get() 方法获取值
         */
        System.out.println(getName() + " count值为：" + atomicInteger.get());
    }
}

public class Test {

    public static void main(String[] args) {


        /**
         * 创建10个线程
         */
        UseConcurrentUtilsThread[] staticThread = new UseConcurrentUtilsThread[10];
        for (int i = 0; i < staticThread.length; i++) {
            staticThread[i] = new UseConcurrentUtilsThread();
        }

        /**
         * 启动10个线程
         */
        for (int i = 0; i < staticThread.length; i++) {
            staticThread[i].start();
        }

        /**
         * 打印结果：
         *    Thread-2 count值为：9114
         *    Thread-9 count值为：10000
         *    Thread-8 count值为：10000
         *    Thread-3 count值为：9496
         *    Thread-5 count值为：9129
         *    Thread-1 count值为：10000
         *    Thread-4 count值为：9942
         *    Thread-7 count值为：9871
         *    Thread-6 count值为：9161
         *    Thread-0 count值为：9119
         *
         * 现在最后一个拿到的数据就是 ：10000。
         *
         * 所以，如果要对int类型的数据操作，并且要保证原子性的时候，就可以直接使用jdk1.5提供的并发包中的工具类。
         */
    }
}