并发访问的线程安全问题

并发能产生问题的状况是，两个线程都去竞争同一个对象才会产生问题，若是你的静态方法只是简单的逻辑是不会有问题的，可是若是你的线程都是去修改静态变量的值的话，应该是会形成线程问题的

总的结论：java是线程安全的，即对任何方法（包括静态方法）均可以不考虑线程冲突，但有一个前提，就是不能存在全局变量。若是存在全局变量，则须要使用同步机制。

以下经过一组对比例子从头讲解：
       在多线程中使用静态方法会发生什么事？也就是说多线程访问同一个类的static静态方法会发生什么事？是否会发生线程安全问题？
public class Test {
    public static void operation(){
        // ... do something
    }
}
       事实证实只要在静态函数中没有处理多线程共享数据，就不存在着多线程访问同一个静态方法会出现资源冲突的问题。下面看一个例子：
public class StaticThread implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        StaticAction.print();
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(new StaticThread()).start();
        }
    }
}
public class StaticAction {
    public static int i = 0;
    public static void print() {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            System.out.print("step " + i + " is running.");
            sum += i;
        }
        if (sum != 45) {
            System.out.println("Thread error!");
            System.exit(0);
        }
        System.out.println("sum is " + sum);
    }
}
       实际执行的结果显示各个线程对静态方法的访问是交叉执行的，可是这并不影响各个线程静态方法print()中sum值的计算。也就是说，在此过程当中没有使用全局变量的静态方法在多线程中是安全的，静态方法是否引发线程安全问题主要看该静态方法是否对全局变量（静态变量static member）进行修改操做。
       在多线程中使用同一个静态方法时，每一个线程使用各自的实例字段(instance field)的副本，而共享一个静态字段(static field)。因此说，若是该静态方法不去操做一个静态成员，只在方法内部使用实例字段(instance field)，不会引发安全性问题。       可是，若是该静态方法操做了一个静态变量，则须要静态方法中采用互斥访问的方式进行安全处理。咱们来看一下没有使用互斥访问的话会产生怎样的问题：public class StaticAction {    public static int i = 0;    public static void incValue() {        int temp = StaticAction.i;        try {            Thread.sleep(1);        } catch (Exception e) {            e.printStackTrace();        }        temp++;        StaticAction.i = temp;    }}public class StaticThread implements Runnable {    @Override    public void run() {        // TODO Auto-generated method stub        StaticAction.incValue();    }    public static void main(String[] args) {        for (int i = 0; i < 100; i++) {            new Thread(new StaticThread()).start();        }        try {            Thread.sleep(1000);    //预留足够的时间让上面的线程跑完        } catch (Exception e) {            e.printStackTrace();        }        System.out.println(StaticAction.i);    }}       实际运行结果显示i值为随机的数字。为了实现互斥访问，这时咱们须要加入一个synchronized关键字。代码修改以下：public class StaticAction {    public static int i = 0;    public synchronized static void incValue() {        int temp = StaticAction.i;        try {            Thread.sleep(1);        } catch (Exception e) {            e.printStackTrace();        }        temp++;        StaticAction.i = temp;    }}public class StaticThread implements Runnable {    @Override    public void run() {        // TODO Auto-generated method stub        StaticAction.incValue();    }    public static void main(String[] args) {        for (int i = 0; i < 100; i++) {            new Thread(new StaticThread()).start();        }        try {            Thread.sleep(1000);        } catch (Exception e) {            e.printStackTrace();        }        System.out.println(StaticAction.i);    }}       运行结果则必然是100。       加入synchronized关键字的静态方法称为同步静态方法。       在访问同步静态方法时，会获取该类的“Class”对象，因此当一个线程进入同步的静态方法中时，线程监视器获取类自己的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，由于多个线程能够同时访问不一样实例同步实例方法。这个其实就是操做系统中的用信号量实现进程的互斥与同步问题，若是涉及在同一个类中有多个静态方法中处理多线程共享数据的话，那就变成用信号量解决生产者-消费者问题。也就是说，静态方法是一份临界资源，对静态方法的访问属于进入临界区；对静态变量的修改是一份临界资源，对静态变量的修改属于进入临界区。