我们先来讨论一个问题，一个类的静态变量当类被多次实例化的时候，静态变量是否会受影响？首先我们应该清楚的是静态变量是在类被JVM classloader的时候分配内存，并且是分配在永久区而非堆内存中。

当我们用对象锁来同步静态变量的时候，我们来看一个例子。
public interface OrderService {

public String getOrderNo();

}
先定义一个接口，获取一个订单编号。
public class OrderLockServiceImpl implements OrderService {

static int num = 0;
@Override
synchronized public String getOrderNo() {
    SimpleDateFormat date = new SimpleDateFormat("YYYYMMDDHHMMSS");
    return date.format(new Date()) + num++;
}

}
实现这个接口，并且用对象方法来操作静态变量。
public class OrderTask implements Runnable {

private CountDownLatch latch;
private OrderService orderService;
public OrderTask(CountDownLatch latch,OrderService orderService) {
    this.latch = latch;
    this.orderService = orderService;
}

@Override
public void run() {
    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.printf("线程名%s订单号:%s\n",Thread.currentThread().getName(), orderService.getOrderNo());
}

}
创建一个线程类，使用CountDownLatch来让每一个线程都有出现的机会，而不是某一个线程独占。
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CountDownLatch latch = new CountDownLatch(1);
for (int i = 0;i < 10;i++) {

  OrderService orderService = new OrderLockServiceImpl();
  service.submit(new OrderTask(latch,orderService));

}
latch.countDown();
service.shutdown();
}
最后实现main方法，用线程池来提交10次线程任务。结果我们发现，这个静态变量会出现重复（并不是每一次运行都会重复）

线程名pool-2-thread-1订单号:20180719619072331
线程名pool-2-thread-7订单号:20180719619072337
线程名pool-2-thread-3订单号:20180719619072337
线程名pool-2-thread-9订单号:20180719619072336
线程名pool-2-thread-5订单号:20180719619072335
线程名pool-2-thread-6订单号:20180719619072334
线程名pool-2-thread-10订单号:20180719619072333
线程名pool-2-thread-4订单号:20180719619072330
线程名pool-2-thread-2订单号:20180719619072332
线程名pool-2-thread-8订单号:20180719619072338

由此我们可以断定，对象锁并不能保证静态变量的同步安全。不过如果对象在堆内存中是唯一的，如
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CountDownLatch latch = new CountDownLatch(1);
OrderService orderService = new OrderLockServiceImpl();
for (int i = 0;i < 10;i++) {

  service.submit(new OrderTask(latch,orderService));

}
latch.countDown();
service.shutdown();
}
则无论你运行多少次，则静态变量也一定是同步的。

但是如果我们使用的是类锁，来改进上面的代码。
public abstract class AbstractOrderService implements OrderService {

static int num = 0;
public static synchronized String getOrderNo2() {
    SimpleDateFormat date = new SimpleDateFormat("YYYYMMDDHHMMSS");
    return date.format(new Date()) + num++;
}
@Override
public String getOrderNo() {
    return getOrderNo2();
}

}
抽象类中使用静态方法，来同步静态变量。
public class OrderLockServiceImpl extends AbstractOrderService {

}
我们在子类中什么都不做，只继承于抽象类

此时我们即便实例化10个对象
for (int i = 0;i < 10;i++) {
OrderService orderService = new OrderLockServiceImpl();
service.submit(new OrderTask(latch,orderService));
}
其结果依然无论运行多少次，都不会出现重复订单号，因为这里已经使用了类锁来同步静态变量。