System.out.println的神奇之处

两个小例子讲解System.out

其实本文章讲解的是System.out.println可能带来的误区

  • volatile与system.out组合产生的误区
  • 主内存与工作内存的“小桥梁“

volatile与system.out组合产生的误区

Volatile关键字大家并不是很陌生,他有两个特性,一个是可见性,第二个就是禁止重排序(具体说明是重排序,感兴趣的话去搜下就有,我这里就不做讲解),但是大家也非常清楚,他并不保证原子性。

下面有个例子就可以说明:
代码如下:

public class VolatileTest {
    public static volatile int race = 0;

    public static final Object obj = new Object();

    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {                     
            for (int i = 0; i < 10000; i++) {
                                increase();
                    }
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 1)
            Thread.yield();
        System.out.println(race);
    }
}

这个例子就是说我启用20个线程并且每个线程循环increase()方法10000次,如果保证原子性的情况下应该输出结果是200000次,但是结果往往不是这个数值(而且不变的)。

上面是从表现的层面上来说明了他不能保证原子性。
如果更深层次层面的去看这个问题:

 0: getstatic     #2
 3: iconst_1
 4: iadd
 5: putstatic     #2

这四个是执行race++的四个指令,就是说当我getstatic拿到值得时候是正确的,但是当我执行iadd指令的时候,其他线程可能已经执行putstatic指令,所以我再iadd的时候,其实值是变小了,从这里也看出他并非保证原子性。

increase();
System.out.println(race);
如果你在increase()方法下加入这句话,就会发现结果不管怎么运行都是200000。

这不是很奇怪么,明明race不能保证原子性,为什么输出确实能保证是线程安全的。

问题就是出在System.out.println()这里,
点击查看他的源码会发现:

public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
}

会发现每次输出都是被同步加锁,其实读到这,很多读者还是会觉得不对劲,因为加锁的只是输出这句话,race++又没被加锁,按常理会出现值重复的情况,但是结果并非如此。

Jvm虚拟机中有个锁优化原则之一就是“锁粗化”,何为锁粗化,但是如果一系列的连续操作都对同一个对象反 复加锁和解锁,甚至加锁操作是出现在循环体中的,那即使没有线程竞争,频繁地进行互斥 同步操作也会导致不必要的性能损耗。
所以加了System.ou.println()之后相当于代码变成了:

synchronized (obj) {
    for (int i = 0; i < 10000; i++) {
        increase();                                
    }
}

所以现象可能给初学者带到一种误区,会认为他存在原子性,我用这个例子就是想说明的是volatile的可见性但是不保证原子性。

主内存与工作内存的“小桥梁“

  第二个例子就是关于主内存和工作内存,先看下运行代码:
public class TestBooleanStop implements Runnable{

    public  boolean flag=true;

    @Override
    public void run() {
            while(flag){
                //...
        }
    }
    public static void main(String[] args) throws Exception {
        TestBooleanStop testBooleanStop = new TestBooleanStop();
        Thread t=new Thread(testBooleanStop);
        t.start();
        Thread.sleep(3000);
        testBooleanStop.flag=false;
        Thread.sleep(3000);
        System.out.println(testBooleanStop.flag);

    }
}

这代码很简单,启动一个线程进入死循环,然后修改flag观察线程是否停止并输出flag,但是程序运行结果是flag的确为false,但是程序并没有停止,还是一直在运行。

如果在循环体中放入:i++

int i=0;
while(flag){
 i++;
        }

这样子程序依然是不会停止。

但是你在循环体中加入System.out.println(…)就会发现程序就会停止。

while(flag){
   System.out.println(...);
        }

其实最关键的还是在System.out.println,他每次输出都会清除工作内存去同步主内存,由于我们修改的flag存在在主内存,所以每次输出去同步的话必然会把flag更新到我们的工作内存当中并且停止了程序运行。

而synchronized是做了什么的操作呢
获得同步锁;
1、清空工作内存;
2、从主内存拷贝对象副本到工作内存;
3、执行代码(计算或者输出等);
4、刷新主内存数据;
5、释放同步锁。

所以system.out.println是主内存和工作内存之间的小桥梁。

这是我个人对这些现象的看法和分析,如果大家觉得有更好的角度去分析多多指教,我也会去更正改正。
  • 2
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值