如何使用多线程在java中增加volatile int？答案

【问题标题】：How to increase volatile int in java using multiple thread?如何使用多线程在java中增加volatile int？
【发布时间】：2016-02-20 05:02:38
【问题描述】：

我有一个 volatile int 变量，其值为 0，我想使用 5 个线程将其增加到 100。我正在尝试从0 到100 生成没有重复的结果。谁能帮我解决这个问题。

我尝试这种方法。合适吗？

public class Producer implements Runnable {
    VolatileIncrement vo = null;
    String str = null;
    Producer(VolatileIncrement vo, String str){
        this.vo = vo;
        this.str = str;
    }

    @Override
    public void run() {
        while(vo.i < 100){
            System.out.println(str+vo.increaseI());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
    }
}

public class VolatileIncrement {    
    volatile Integer i = 0;
    public synchronized int increaseI() {
            i++;
            return i;
        }
    }
}

public class ProducerMain {
    public static void main(String[] args) {
        VolatileIncrement vo = new VolatileIncrement();
        Producer p1 = new Producer(vo,"I am thread 1 - ");
        new Thread(p1).start();
        Producer p2 = new Producer(vo,"I am thread 2 - ");
        new Thread(p2).start();
        Producer p3 = new Producer(vo,"I am thread 3 - ");
        new Thread(p3).start();
        Producer p4 = new Producer(vo,"I am thread 4 - ");
        new Thread(p4).start();
        Producer p5 = new Producer(vo,"I am thread 5 - ");
        new Thread(p5).start();
    }
}

【问题讨论】：

也许使用AtomicInteger
我尝试以下方法。
volatile 优先用于要求分配和自动缓存刷新的情况。在您的情况下，因为可以同时进行加法和赋值操作。你要么需要使用同步，要么像其他人说的那样，使用AtomicInteger。
有什么原因不能使用java.util.concurrent.atomic.AtomicInteger???
是的。 AtomicInteger 也解决了这个问题。感谢您的快速回复。

标签： java multithreading synchronized volatile

【解决方案1】：

您可以使用 atomic1 类通过多线程更新整数

AtomicLong counter = new AtomicLong(0);
counter.getAndIncrement();

它在单个变量上是无锁和线程安全的。

【讨论】：

【解决方案2】：

int counter=0;
public static synchronized void increase()
{
     counter++;
}

调用这个方法。由于它声明为同步，一次只有一个线程会起作用（即一次递增）。

【讨论】：

【解决方案3】：

a) 如果对该变量的所有访问都在同步块内，则没有理由使用 volatile。 Synchronized 比 volatile 在线程之间同步内存的范围更大。

b) 你不能做一个简单的 i++ atomic；你需要同步，或者可重入锁，或者说的 AtomicInteger。

【讨论】：