展开全部
其实我个人觉得语32313133353236313431303231363533e58685e5aeb931333433646436言的选择，不能说决定代码的稳定性，或者说是可维护性的高低，因为这两个主要还是看代码的本身。
编码可以说所有的东西JAVA还有PHP主要都是看编码和代码的。也可以这样说JAVA，大小写比较敏感。但是PHP对方法名啊，或者函数。这些基本上是不区分大小写的他都可以的。
其实我个人觉得，如果说是用JAVA的话可以更好的让你更加流利，或者说是更加快捷方便的去写一个更好的统一的一个编码，或者说一个代码这样话就会利于维护啊，或者阅读这样的话，你其实用JAVA的话会比较方便一些，毕竟PHP他之间相互的过程方程式啊，这些编程的问题可能没有JAVA方便。
入门而言其实因为JAVA的一些门道儿，就像他对大小写啊，他就必须要十分规范地写出来。所以说，你再这样的训练之下，你做出来的东西就会比较规范，比较稳定了。
但是PHP吧，这个东西写的就很随意一点，比如说大小写，不需要那么区分啊，然后你觉得就是说你自己可以完成啊，并且说如果说作为入门的话，其实我个人觉得会更多人喜欢PHP吧，因为这样的话你就觉得其实自己是可以操作的了，可以写出来的，但是。PHP那些不规格的方式可能会毁了你，因为你已经习惯于不用区分大小写之类的。毕竟这的规范模板。就像网上流传的一句话。
总结其实我个人来说的话你不管说是用JAVA还是用PHP的话，其实这个东西都是看个人的吧。JAVA像是一个建筑家，但是PHP是一个流浪派的艺术家
因为你这个的话，有的人其实从刚开始学习的时候，他就会比较规范，那就会觉得JAVA的那些条条框框，对于他来说没有一定的限制，更加的清晰明白。你如果说从一开始就是大小写或者那些规矩啊，没有弄清楚，然后你就会觉得PHP，更喜欢，因为这样的话你就会觉得，没有那么多的事儿，但是我还是可以编辑成语言，然后接着还是可以调成一个很完美的语言。
但是你如果说哪个更加的安全稳定，并且可以维护的话，这个就看开发者的水平来保证的是没有办法说他们两个到底哪个更好，因为完全取决于代码，编程的问题就是掌握在使用的人的手里。

我们都知道volatile能保证可见性，不能保证原子性，比如i++操作
也知道Happen-Before原则，那么是如何确保Happen-Before原则不被指令重排序影响呢？(如果对上述描述有困惑请移步[高并发Java 三] Java内存模型和线程安全)
例如你让一个volatile的integer自增(i++)，其实要分成3步：1)读取volatile变量值到local； 2)增加变量的值；3)把local的值写回，让其它的线程可见。这3步的jvm指令为：
mov
0xc(%r10),%r8d
; Load
inc
%r8d           ; Increment
mov
%r8d,0xc(%r10)
; Store
lock
addl $0x0,(%rsp)
; StoreLoad Barrier
StoreLoad Barrier就是内存屏障
内存屏障(memory barrier)是一个CPU指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。
内存屏障和volatile什么关系？上面的虚拟机指令里面有提到，如果你的字段是volatile，Java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作，你必须知道：1、一旦你完成写入，任何访问这个字段的线程将会得到最新的值。2、在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。
明白了内存屏障这个CPU指令，回到前面的JVM指令：从Load到store到内存屏障，一共4步，其中最后一步jvm让这个最新的变量的值在所有线程可见，也就是最后一步让所有的CPU内核都获得了最新的值，但中间的几步(从Load到Store)是不安全的，中间如果其他的CPU修改了值将会丢失。
所以volatile不能保证i++操作的原子性

为什么Java程序员的薪资一直居高不下？Java作为最热门的软件开发语言之一，一直受到众多开发爱好者的认可和追捧，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网特别是适合于开发企业级应用：金融，电信，物流，电商，医院等系统。因为其具有卓越的通用性、高效性、平台移植性和安全性，目前为止仍然是很火的编程语言，拥有全球最大的开发者专业社群。

程序员的工资到底有多高



上图中数据取自全国 239380 份样本，职位平均工资为13270元。

①其中北京的平均工资最高，在 32805样本中平均工资为21370元；

②而上海在30646份样本中以平均工资18230元紧随其后；

③另外深圳在25879份样本中平均工资为16680元；

④广州在20561份样本中平均工资为13440元。



Java行业市场需求存在巨大的缺口

据不完全统计，几乎90%以上的大中型互联网应用系统在服务器端开发首选Java，全球有25亿Java服务在运行。这几年中国在移动互联网这块发展非常迅猛，Java开发的需求变得更大人才发展跟不上市场需求的现状，给优秀Java人才开出的薪资待遇随之水涨船高。



Java程序员的门槛相对比较高

一般优先选择计算机相关专业的大学生，原因有二，一是，Java对从业人员素质有一点要求，计算机相关行业会了解较基本的互联网的相关知识，以及简单的语言基础；二是，从事这一行业，招聘公司对学历也有一定要求。

当然，也有非计算机专业的从事Java行业的人转行做Java开发。那么则需要付出更大的努力，在计算机、数学、逻辑思维方面进行提升，但有的人没有用正确的方法系统的学习，走了不少弯路不说，遇到困难解决不了，还没入门就放弃了。
对于在职的Java从业人员来讲，不断的努力吸收新的知识，跟上互联网进步的节奏也是很重要的。

一、前言

可能大家在学习java的基础过程中，都知道StringBuilder相对StringBuffer效率更高，但是线程不安全。可是，到底是怎么个不安全法，反正我是懵的。借此机会，写个小代码测试下。

二、编码

既然是测试StringBuilder和StringBuffer的线程安全性，那就分别new一个StringBuilder和StringBuffer作为共享变量，传递到多个线程进行操作，看看最后结果如何。

package com.cjt.test;

public class Test {

  public static void main(String[] args) {
    StringBuilder builder = new StringBuilder();
    StringBuffer buffer = new StringBuffer();

    for (int i = 0; i < 10; i++) {
      new A(builder, buffer).start();
    }
  }
}

class A extends Thread {

  private StringBuilder builder;

  private StringBuffer buffer;

  A(StringBuilder builder, StringBuffer buffer) {
    this.buffer = buffer;
    this.builder = builder;
  }

  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      builder.append("c");
      buffer.append("c");

      try {
        Thread.sleep(10);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    System.out.println("[" + Thread.currentThread().getName() + "]builder:" + builder.length());
    System.out.println("[" + Thread.currentThread().getName() + "]buffer:" + buffer.length());
  }
}


三、分析测试

我在run()里面加了一个Thread.sleep(10)延时，为了更好地体现多个线程操作同一个变量的安全性问题。运行结果：

[Thread-9]builder:939
[Thread-5]builder:939
[Thread-9]buffer:994
[Thread-5]buffer:994
[Thread-1]builder:941
[Thread-1]buffer:996
[Thread-4]builder:941
[Thread-4]buffer:996
[Thread-0]builder:941
[Thread-0]buffer:996
[Thread-8]builder:941
[Thread-8]buffer:996
[Thread-2]builder:942
[Thread-2]buffer:998
[Thread-6]builder:942
[Thread-6]buffer:998
[Thread-3]builder:944
[Thread-3]buffer:1000
[Thread-7]builder:944
[Thread-7]buffer:1000


说实话当我运行后也是一头问号？什么鬼，没有任何规律可寻。的确是这样，但是经过多次运行后可以总结一点是：StringBuffer最终的length总是1000，但是StringBuilder的length总是少于1000。

这也太没说服力了~！那就要分别看看它们的append()源码了；

StringBuilder:

public StringBuilder append(String str) {
    super.append(str);
    return this;
}


StringBuffer:

public synchronized StringBuffer append(String str) {
    super.append(str);
    return this;
}


看样子好像就隔只一个synchronized关键字，那就看看super.append(str)的源码吧，但可以吃惊地发现都是AbstractStringBuilder.append(String str)，看看这段代码：

public AbstractStringBuilder append(String str) {
    if (str == null) str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}


由于底层字符串都是由char数组实现的，这里str.getChars(0, len, value, count);就是一个明显的赋值操作。因而可以说StringBuilder和StringBuffer的append(String str)方法都是通过getChars方法来实现字符串拼接的。

有人看到上面还有个ensureCapacityInternal(count + len);调用，这个只是一个底层的char数组扩容计算，有兴趣的可以自己私下看看源码，这里就不贴出来。

那我们就一探getChars方法的究竟：

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
{
    if (srcBegin < 0)
        throw new StringIndexOutOfBoundsException(srcBegin);
    if ((srcEnd < 0) || (srcEnd > count))
        throw new StringIndexOutOfBoundsException(srcEnd);
    if (srcBegin > srcEnd)
        throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
    System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}


实质上是调用底层System.arraycopy()方法实现的，可能你觉得我扯远了，其实，的确有点吧。

StringBuilder中的append方法没有使用synchronized关键字，意味着多个线程可以同时访问这个方法。那么问题就来了额，如果两个线程同时访问到这个方法，那么AbstractStringBuilder中的count是不是就是相同的，所以这两个线程都是在底层char数组的count位置开始append添加，那么最终的结果肯定就是在后执行的那个线程append进去的数据会将前面一个覆盖掉。因此我们的控制台输出才会出现StringBuilder一直都是小于1000的。然而StringBuffer却不会发生这种情况。

三、总结

StringBuilder相比StringBuffer效率更高，但多线程不安全；
	
在单线程中字符串的频繁拼接使用StringBuilder效率更高，对于多线程使用StringBuffer则更安全；
	
字符串简单操作时没必要使用上述两者，还是用String类型提高速度；
原文参考：https://www.jianshu.com/p/2cf1f60b0d9a