静态变量不用考虑线程冲突的问题吗？

Question

我想做一个对象计数器，用一个静态变量存放，每实例化一个对象的时候就将这个对象自增1，但是我就是害怕发生线程冲突。可能发生这种情况吗？如果可能的话，如何避免？

Answer 1

public class Person{
   public static int count = 0;
   public Person(){
    count++;//这种使用方式不会有问题，因为不可能同时存在多个线程同时执行构造函数
   }
}

Answer 2

为什么不可能，
同时多个线程一起new一个对象不可能吗？

Answer 3

public class Main {
public static int count;
public static countAdd{
++count;
}
}

Answer 4

public static int count;
public static void countAdd(){
++count;
}
}

Answer 5

看了你的需求其实很简单啊  用  synchronized 去修饰你计数方法~~~就可以解决并发问题了

Answer 6

如果一个静态变量如果不考虑一些操作 如:
对变量的写操作不依赖于当前值。
该变量没有包含在具有其他变量的不变式中。
那么可以用 Volatile  修饰这个变量 。
Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式（Invariants）的类

Answer 7

没太看懂楼主的意思。
你的意思是不是说多线程中考虑线程同步的问题？
如果是的话，那么你需要使用同步机制。同步机制的实现有两种，其中一种是直接使用synchronized关键字。举个例子public class Test{
    private static int count = 0;
    
    public synchronized void inc(){
        count ++;
    }
}这样就不会冲突。

Answer 8

public class Test {  private static boolean inUse;  public Test() {
    if (inUse) {
      throw new IllegalStateException();
    }
    inUse = true;
    try {
      Thread.sleep(100);
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
    inUse = false;
  }  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      new Thread() {
        public void run() {
          for (;;) {
            new Test();
          }
        }
      }.start();
    }
  }
}

Answer 9

即使不sleep，结果也是一样，构造函数又不是static段。
public class Test {  private static boolean inUse;  public Test() {
    if (inUse) {
      throw new IllegalStateException();
    }
    inUse = true;
    inUse = false;
  }  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      new Thread() {
        public void run() {
          for (;;) {
            new Test();
          }
        }
      }.start();
    }
  }
}

Answer 10

好像这个有点不对哦 在使用new 时 ，会进行一些初始化 然后才执行构造函数体的 ，如果同时在进行初始化时 ，那么就会有冲突了

Answer 11

synchronized(syncObject) { 
//允许访问控制的代码 
}这段代码求大牛详解下呗放在括号里的那个对象是干什么用的呢？

Answer 12

这算是最基础的问题了，不用大牛大牛的整天喊，多看看书吧。至少了解小synchronized用法

Answer 13

这里的syncObjecto  就是我们常说的对象锁。只有得到这个syncObject 锁，才可以开始这块同步的代码。

Answer 14

只计数用AtomicInteger这玩意就行了，简单方便

Answer 15

顺便问下，synchronized为什么不能锁基本类型。

Answer 16

你是说synchronized(xxx) {...}吗？只能锁对象
如果问为何int的count++会有线程安全性问题，那是因为，JLS只规定了单个int/float的读or写是原子的，但是由于count++涉及到读+写，因此多线程下不安全。

Answer 17

涉及线程同步时，最好使用synchronized关键字修饰方法，volatile关键字同步性能不是很好（尽管volatile关键字可以保持数据的可见性），比不上synchronized，使用多个synchronized方法互斥使用都不会出现问题的

Answer 18

我问为什么不能锁基本类型，和你说的只能锁对象不就一个意思吗，没有答出实质。
int a=3;
synchronized(a){
     
   a.wait();
}
对于基本类型没有方法wait,nodify，这样答还比较好点。
对于锁引用和锁基本类型实质都是在栈中。

Answer 19

使用volatile关键字声明int变量
或者使用AtomicInteger

Answer 20

查下Signleton模式就可以解决了！

Answer 21

如果你的类实例是单例的可以这么用private static int count;
public static synchronized void add(){
    count++;
}如果不是单例就private static int count;
private static Object lock = new Object();
public static void add(){
    synchronized(lock)
    {
         count++;
    }
}

Answer 22

public class Test{
    private static AtomicInteger count = new AtomicInteger(0);
    
    public Test(){
        count.incrementAndGet();
    }
}
这样的话就不用锁了,用JAVA的原子就不会发生并发的情况了,最好不要用锁

Answer 23

共享的东西，没有同事的post和get的需求是没有冲突的，如果你要get就要想清楚了

Answer 24

不会用啊
和Integer一样用吗？老师没有教过，要自己查！

Answer 25

我印象中对于静态方法是使用synchronized 即使不是单例，锁照样有效，如果把你写的方法去掉static关键字的话就和你说的一样吧。

Answer 26

想要相关语言的所有资料吗？那就快来吧。
我的压缩包里面不止一两样东西哦，那可是我学习和工作的所有资料，不管是学习还是工作都会需要。
http://download.csdn.net/user/yangtonghai

Answer 27

synchronized("submit"){
i++;
｝试试这个。 我就这样干的。

Answer 28

private static AtomicInteger count；

Answer 29

使用 AtomicInteger 解决问题

Answer 30

AtomicInteger 和int 一样用么？
package test;import java.util.concurrent.atomic.AtomicInteger;public class MainClass {}class c{
static AtomicInteger count = new AtomicInteger();
int number;
c(){
number = count.getAndIncrement();
}
}代码是想这样的么？