静态变量的多线程同步问题

2019独角兽企业重金招聘Python工程师标准>>>

我们先来讨论一个问题，一个类的静态变量当类被多次实例化的时候，静态变量是否会受影响？首先我们应该清楚的是静态变量是在类被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));
}

其结果依然无论运行多少次，都不会出现重复订单号，因为这里已经使用了类锁来同步静态变量。

转载于:https://my.oschina.net/u/3768341/blog/1854233