搜索词>>static关键字 耗时0.0550
  • Java编程之java static关键字

    Java编程之java static关键字,Java编程,static关键字<h2>一、java中static关键字</h2> java中的static关键字可以应用于变量、方法、块、导入和内部类。在本教程中,我们将了解在这些地方使用static关键字的效果。<br /> <br /> 本文将要讲解的内容目录: <ul> <li>Static 变量的使用讲解</li> <li>Static 方法的使用讲解</li> <li>Static 导入声明使用讲解</li> <li>Static 块的使用讲解</li> <li>Static 类的使用讲解</li> <li>static关键字使用总结</li> </ul> <h2>二、static变量</h2> 要声明一个static变量,请在变量声明中使用static关键字。static变量的语法是: <pre> <code>ACCESS_MODIFER static DATA_TYPE VARNAME;</code></pre> 例如,用这种方式声明整数类型的公共静态变量。 <pre> <code class="language-java">public static Integer staticVar;</code></pre> 静态变量最重要的一点是它们属于类级别。这意味着在运行时只能有一个变量的副本。当在类定义中定义静态变量时,类的每个实例都可以访问该单一副本。单独的类实例不会有它们自己的本地副本,就像它们对非静态变量一样。<br /> <br /> 让我们来了解一个例子: <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { DataObject objOne = new DataObject(); objOne.staticVar = 10; objOne.nonStaticVar = 20; DataObject objTwo = new DataObject(); System.out.println(objTwo.staticVar); //10 System.out.println(objTwo.nonStaticVar); //null DataObject.staticVar = 30; //Direct Access System.out.println(objOne.staticVar); //30 System.out.println(objTwo.staticVar); //30 } } class DataObject { public static Integer staticVar; public Integer nonStaticVar; }</code></pre> <br /> 输出内容: <pre> <code>10 null 30 30</code></pre> 注意我们如何将值更改为30,并且这两个对象现在看到的更新值为30。<br /> <br /> 另一件您应该注意到的是,我们如何能够使用它的类名来访问静态变量,即dataobject . staticvar。我们不需要创建任何实例来访问静态变量。它清楚地表明静态变量属于类范围。 <h2>三、static方法</h2> 要声明静态方法,请在方法声明中使用静态关键字。静态方法的语法是: <pre> <code>ACCESS_MODIFER static RETURN_TYPE METHOD_NAME;</code></pre> <br /> 例如,用这种方式声明整数类型的公共静态变量。 <pre> <code class="language-java">public static Integer getStaticVar(){ return staticVar; }</code></pre> <p>要记住的一些事项。</p> <ol> <li>您只能在静态方法中访问静态变量。如果您尝试访问任何非静态变量,将生成的编译器错误信息“无法对非静态字段非静态变量进行静态引用”。</li> <li>静态方法可以通过它的类引用来访问,并且不需要创建类的实例。虽然您也可以使用实例引用,但是与通过类引用的访问相比,它不会有任何不同。</li> <li>静态方法也属于类级范围。</li> </ol>   <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { DataObject.staticVar = 30; //Direct Access Integer value1 = DataObject.getStaticVar(); //access with class reference DataObject objOne = new DataObject(); Integer value2 = objOne.getStaticVar(); //access with instance reference System.out.println(value1); System.out.println(value2); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable public static Integer getStaticVar(){ return staticVar; } }</code></pre> 输出内容: <pre> <code>30 30</code></pre> <h2>四、static Import 声明</h2> <p>    正常的导入声明从包中导入类,因此它们可以在没有包引用的情况下使用。类似地,静态导入声明从类中导入静态成员,并允许它们在没有类引用的情况下使用。</p> <p>    静态导入声明也有两种类型:单静态导入和静态导入。单静态导入声明从类型中导入一个静态成员。静态输入-点播声明导入了类型的所有静态成员。<br />  </p> <pre> <code class="language-java">//Single-static-import declaration: import static <<package name>>.<<type name>>.<<static member name>>; //Static-import-on-demand declaration: import static <<package name>>.<<type name>>.*;</code></pre> 例如, <code>System.out</code> is <pre> <code class="language-java">//Static import statement import static java.lang.System.out; public class JavaStaticExample { public static void main(String[] args) { DataObject.staticVar = 30; out.println(DataObject.staticVar); //Static import statement example } } class DataObject { public static Integer staticVar; //static variable }</code></pre> 输出: <pre> <code>30</code></pre> <h2>五、Static 块</h2> 静态块是类初始化代码的一部分,它用静态关键字包装。一般的语法是: <pre> <code class="language-java">static { //initialize static members of class }</code></pre> 当类装入内存时,将执行静态块。一个类可以有多个静态块,并且它们将以相同的顺序执行,它们在类定义中出现。 <pre> <code class="language-java">import static java.lang.System.out; class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable //It will be executed first static { staticVar = 40; //nonStaticVar = 20; //Not possible to access non-static members } //It will be executed second static { out.println(staticVar); } }</code></pre> 输出: <pre> <code>40</code></pre> <h2>六、static 类</h2> 在java中,可以将静态类作为内部类。与其他静态成员一样,嵌套的类属于类范围,所以可以访问内部的静态类,而不具有外部类的对象。 <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { //Static inner class example System.out.println( DataObject.StaticInnerClas.innerStaticVar ); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable static class StaticInnerClas { Integer innerNonStaticVar = 60; static Integer innerStaticVar = 70; //static variable inside inner class } }</code></pre> 请注意,静态内部类无法访问外部类的非静态成员。它只能访问来自外部类的静态成员。 <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { //Static inner class example DataObject.StaticInnerClas.accessOuterClass(); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable static { staticVar = 40; //nonStaticVar = 20; //Not possible to access non-static members } public static Integer getStaticVar(){ return staticVar; } static class StaticInnerClas { public static void accessOuterClass() { System.out.println(DataObject.staticVar); //static variable of outer class System.out.println(DataObject.getStaticVar()); //static method of outer class } } }</code></pre> 输出: <pre> <code>40</code></pre> <h2>七、总结</h2> 让我们总结一下java中静态使用的所有内容。 <ol> <li>静态成员属于类。不需要创建类实例来访问静态成员。</li> <li>静态成员(变量和方法)只能在静态方法和静态块中访问。</li> <li>不能在静态方法、块和内部类中访问非静态成员。</li> <li>一个类可以有多个静态块,它们将按照类定义的顺序执行。</li> <li>只有当类声明为内部类内部类时,类才能是静态的。</li> <li>静态导入可用于从类导入所有的静态成员。这些成员可以被引用,没有任何类引用。</li> </ol>
  • Python教程-Python保留字符/关键词

    ​Python关键字是python编程语言的保留字,这些关键字不能用于其他目的​Python关键字是python编程语言的保留字,这些关键字不能用于其他目的。Python中有35个关键字-下面列出了它们的用法关键词描述and一个逻辑的“并且”操作,如果所有条件都是True,则返回Truex = (5 > 3 and 5 < 10)print(x)    # Trueor一个逻辑的“或者”操作,如果其中一个条件是true则返回True,如果全部条件都是false,则返回Falsex = (5 > 3 or 5 > 10)print(x)    # Trueas用来创建一个别名import calendar as cprint(c.month_name[1])  #Januaryassert它可以用于调试代码。 它会测试一个条件并返回True,否则返回True。x = "hello" assert x == "goodbye", "x should be 'hello'"  # AssertionErrorasync它被用来声明一个作为协程的函数,就像@ asyncio.coroutine装饰器所做的一样。async def ping_server(ip):await它用于调用异步协程。async def ping_local():    return await ping_server('192.168.1.1')class用于创建一个类class User:  name = "John"  age = 36def它用于创建或定义函数/方法。def my_function():  print("Hello world !!") my_function()del它用于删除对象。 在Python中,所有事物都是对象,因此del关键字也可用于删除变量,列表或列表的一部分等。x = "hello" del xif它用于创建条件语句,该条件语句仅在条件为True时才允许我们执行代码块。x = 5 if x > 3:  print("it is true")elif他是 else if的缩写i = 5 if i > 0:    print("Positive")elif i == 0:    print("ZERO")else:    print("Negative")else它在if..else语句中确定条件为False时该如何处理。i = 5 if i > 0:    print("Positive")else:    print("Negative")它也可以用在try ...区块中。x = 5 try:    x > 10except:    print("Something went wrong")else:    print("Normally execute the code")try它定义了一个代码块来测试它是否包含任何错误。except如果try块引发错误,它将定义要运行的代码块。try:    x > 3except:    print("Something went wrong")finally它定义了一个代码块,无论try块是否引发错误,该代码块都将执行。try:    x > 3except:    print("Something went wrong")finally:     print("I will always get executed")raise它用于手动引发异常。x = "hello" if not type(x) is int:    raise TypeError("Only integers are allowed")False它是一个布尔值,与0相同。True它是一个布尔值,与1相同。for它用于创建for循环。 for循环可用于遍历序列(如列表,元组等)。for x in range(1, 9):    print(x)while它用于创建while循环。 循环继续进行,直到条件语句为假。x = 0 while x < 9:    print(x)    x = x + 1break它用于中断for循环或while循环。i = 1 while i < 9:    print(i)    if i == 3:        break    i += 1continue它用于在for循环(或while循环)中结束当前迭代,并继续进行下一个迭代。for i in range(9):    if i == 3:        continue    print(i)import它用于导入模块。import datetimefrom它仅用于从模块中导入指定的节。from datetime import timeglobal它用于从非全局范围创建全局变量,例如 在函数内部。def myfunction():    global x    x = "hello"in1.用于检查序列(列表,范围,字符串等)中是否存在值。2.它也用于迭代for循环中的序列。fruits = ["apple", "banana", "cherry"] if "banana" in fruits:    print("yes") for x in fruits:    print(x)is它用于测试两个变量是否引用同一对象。a = ["apple", "banana", "cherry"]b = ["apple", "banana", "cherry"]c = a print(a is b)   # Falseprint(a is c)   # Truelambda它用于创建小的匿名函数。 它们可以接受任意数量的参数,但只能有一个表达式。x = lambda a, b, c : a + b + c print(x(5, 6, 2))None它用于定义一个空值或完全没有值。 None与0,False或空字符串不同。None是它自己的数据类型(NoneType),并且只有None可以是None。x = None if x:  print("Do you think None is True")else:  print("None is not True...")      # Prints this statementnonlocal它用于声明变量不是局部变量。 它用于在嵌套函数内部使用变量,其中变量不应属于内部函数。def myfunc1():    x = "John"    def myfunc2():        nonlocal x        x = "hello"    myfunc2()    return x print(myfunc1())not它是一个逻辑运算符,并反转True或False的值。x = False print(not x)    # Truepass它用作将来代码的占位符。 当执行pass语句时,什么也不会发生,但是当不允许使用空代码时,可以避免出现错误。循环,函数定义,类定义或if语句中不允许使用空代码。for x in [0, 1, 2]:            passreturn它是退出一个函数并返回一个值。def myfunction():            return 3+3with用于简化异常处理yield要结束一个函数,返回一个生成器
  • Spring Boot 配置映射本地资源访问

    Spring Boot 配置映射本地资源访问注意配置为两个spring.mvc.static-path-pattern= spring.resources.static-locations=这两个配置的默认值是:spring.mvc.staSpring Boot 配置映射本地资源访问注意配置为两个spring.mvc.static-path-pattern= spring.resources.static-locations=这两个配置的默认值是:spring.mvc.static-path-pattern=/** spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/ 解释一下:这两个的默认配置意思是请求来了 /路径下的,先去找spring.resources.static-locations配置的几个目录下有没用静态的资源文件。访问各个目录的优先级为从左到右由高到低。问题来了,我们如果想添加一个本地的绝对路径映射该怎么配置呢?spring.resources.static-locations=classpath:/static,D:/sharew我最初以为这样就可以了,然而后面的配置并没有生效。。。。。注意!注意!注意!要像下面这样配置才能生效。spring.resources.static-locations=classpath:/static,file:D:/share
  • Vue2.x父子组件相互通信

    一、前言Vue 2.x 使用期间,我们会创建众多组件,这里我们将讨论一下各个组件直接的相互通讯问题如何解决一、前言Vue 2.x 使用期间,我们会创建众多组件,这里我们将讨论一下各个组件直接的相互通讯问题如何解决。二、Vue 2.x组件相互通讯原理在 Vue.js 中,父子组件的关系可以总结为 props down, events up 。父组件通过 props 向下传递数据给子组件,子组件通过 events 给父组件发送消息。看看它们是怎么工作的。​Vue 2.x组件相互通讯原理三、子组件 这里的子组件是模拟的一个搜索组件,包含返回、搜索等事件。只用关注组件的值传递即可。$title(child.vue) <template> <!--搜索条--> <div class="search-back-section searchHead flex-between animated" :class="activeClass"> <mu-button class="back" flat color="#444444" @click="back"><i class="fa fa-angle-left" aria-hidden="true"></i></mu-button> <mu-text-field :value="searchKeyword" v-model="text" :placeholder="'请输入:'+placeholder" :error-text="error" ></mu-text-field> <mu-button small class="btn" flat color="#444444" @click="search">搜索</mu-button> </div> </template> <script> import verify from "../assets/js/verify"; export default { name: "com-search-back-section", props: [ "back", //"返回按钮" "searchKeyword", //搜索关键字 "placeholder", //输入框提示 "error", //错误提示 "activeClass", //绑定CSS样式 ], data() { return { text: "", } }, watch:{ searchKeyword(val){ this.text=val; } }, created() { this.text = this.searchKeyword; }, methods: { search() { let msg = ""; if (verify.isEmpty(this.text)) { msg = this.text; } else { msg = false; } this.$emit("search", msg); } }, } </script> <style scoped> //样式代码与本文主题关系不大,省略 </style> 划重点props: [ "back", //"返回按钮" "searchKeyword", //搜索关键字----重点 "placeholder", //输入框提示 "error", //错误提示 "activeClass", //绑定CSS样式 ] watch:{ searchKeyword(val){ this.text=val; //---重点 } } 通过watch监视props中的属性值以及data中属性与数据的双向绑定,实现了外部数据的双向绑定。注意:父组件中定义子组件绑定属性的名称对应的是子组件props里面定义的名称一致search() { let msg = ""; if (verify.isEmpty(this.text)) { msg = this.text; } else { msg = false; } this.$emit("search", msg); //---重点 }通过$emit向外面抛出一个回调函数传递当前组件的值数据。四、父组件$title(patent.vue) <template> 其他省略--- <!--搜索框--> <search-back-section :active-class="isFixedState?'isFixed fadeInDown':''" :back="closeFullscreenDialog" :searchKeyword="searchKeyword" //-----重点 :placeholder="'关键字'" @search="searchBtn" :error="errorText" ></search-back-section> 其他省略--- </template> <script> let _self=null; export default { name: "door-home", data() { return { errorText: "", //错误信息 searchKeyword: "", //关键字 isFixedState:false //用于判断css样式选择,与主题无关 }, created() { _self=this; this.searchKeyword='默认的值'; //---重点 会看到初始化的子组件中输入框默认值为‘默认的值’(实现了父向子传递数据) }, methods: { /* * @"搜索"按钮 * */ searchBtn(msg) {------重点 通过子向外抛出的回调函数,子组件向父组件传递子组件中输入的内容值(实现了子向父传递数据) if (msg) { this.searchKeyword = msg; this.errorText = ""; } else { this.errorText = "请输入关键字."; return false; } } closeFullscreenDialog(){ //关闭搜索操作,与主题无关代码省略 } }, }; </script>注意:父组件中定义子组件绑定属性的名称对应的是子组件props里面定义的名称一致,传值是通过props传递所以必须一致。例子中的 :searchKeyword="searchKeyword"前面的searchKeyword是子组件的props定义的,后面这个是当前父组件定义的,后方这个searchKeyword可以随意其他名称
  • Spring boot/Spring MVC 判断是否AJAX请求

    ​Spring Boot 或者Spring MVC 判断请求类型是否为Ajax请求具体如下:public static boolean isAjaxRequest(HttpServletRequest request) {         ​Spring Boot 或者Spring MVC 判断请求类型是否为Ajax请求具体如下:public static boolean isAjaxRequest(HttpServletRequest request) {         String requestedWith = request.getHeader("x-requested-with");         if (requestedWith != null && requestedWith.equalsIgnoreCase("XMLHttpRequest")) {             return true;         } else {             return false;         }     }
  • java多线程编程_java多线程安全_java多线程实现安全锁CAS机制

    java多线程编程_java多线程安全_java多线程实现安全锁CAS机制,CAS在java多线程中相当于数据库的乐观锁,synchronized相当于数据库的乐观锁。<h2>引言</h2>     java多线程编程中难免会遇到资源共享。这里将会讲解一下java多线程中的CAS机制和锁的基础概念。java多线程编程_java多线程安全_java多线程实现安全锁CAS机制,CAS在java多线程中相当于数据库的乐观锁,synchronized相当于数据库的乐观锁。 <h2>一.java多线程编程常见问题</h2> <strong><a rel="external nofollow" target="_blank" id="java多线程1" name="java多线程1">java多线程示例程序</a>:</strong>启动两个线程,每个线程中让静态共享变量count循环累加100次<br /> <br /> <a rel="external nofollow" target="_blank" id="java多线程代码" name="java多线程代码"><strong>java多线程示例代码</strong></a>: <pre> <code class="language-java">package xqlee.net.project.demo.thread.synchronize; public class ForTest { public static int count = 0; public static void main(String[] args) { // 开启两个线程 for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(10); } catch (Exception e) { e.printStackTrace(); } //每个线程累计加100 for (int j = 0; j < 100; j++) { count++; // System.out.println(count); } } }).start(); } try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } System.out.println("count=" + count); } } </code></pre> <strong>疑惑</strong>:<span style="color:#6600ff">最终输出的count结果是多少呢?两个线程执行完毕一定是200吗?</span><br /> <br /> <strong>答案</strong>:因为这段代码不是线程安装的,所以最终的自增结果很有可能会小于200。<br /> <strong>尝试执行结果</strong>:<br /> <img alt="java多线程演示代码执行结果" class="img-thumbnail" src="/assist/images/blog/00053be4566b4b93acc2f6e7b13e93bf.png" /><br /> 接下来,修改上面的演示代码。通过关键字synchronized在java多线程编程实现中添加一个锁。这个是个重量级的锁。后续详说。<br /> 修改后演示代码如下: <pre> <code class="language-java">package xqlee.net.project.demo.thread.synchronize; public class ForTest { public static int count = 0; public static void main(String[] args) { // 开启两个线程 for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(10); } catch (Exception e) { e.printStackTrace(); } //每个线程累计加100 for (int j = 0; j < 100; j++) { synchronized (ForTest.class) { count++; } // System.out.println(count); } } }).start(); } try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } System.out.println("count=" + count); } } </code></pre> <br /> 再次执行演示代码,查看结果:<br /> <img alt="java多线程编程加锁后的执行结果" class="img-thumbnail" src="/assist/images/blog/0ef74f747d6c440c8f62513431d9b462.png" /><br />     加了同步锁之后,count自增的操作变成了原子性操作,所以最终的输出一定是<strong>count=200</strong>,代码实现了线程安全。<br /> <br />     但是注意,虽然synchronized确保了线程的安全,但是在某些情况下,却不是一个最优选择。为啥这么说呢?关键在于synchronized存在性能问题。synchronized关键字会让没有得到锁资源的线程进入BLOCKED状态,而后再争夺到锁资源后恢复为RUNNABLE状态,这个过程中涉及到操作系统<strong>用户模式</strong>和<strong>内核模式</strong>的转换,代价比较高。尽管Java1.6为Synchronized做了优化,增加了从<strong>偏向锁</strong>到<strong>轻量级锁</strong>再到<strong>重量级锁</strong>的过度,但是在最终转变为重量级锁之后,性能仍然较低。<br /> <br /> <br /> 那么有啥好的其他解决办法嘛?<br /> 有:原子操作类;<br /> <img alt="JDK中的原子操作类" class="img-thumbnail" src="/assist/images/blog/4a065fca722e4577982931e44fe71839.png" /> <p>  所谓原子操作类,指的是java.util.concurrent.atomic包下,一系列以Atomic开头的包装类。例如<strong>AtomicBoolean</strong>,<strong>AtomicInteger</strong>,<strong>AtomicLong</strong>。它们分别用于Boolean,Integer,Long类型的原子性操作。</p> <p>现在我们尝试在代码中引入AtomicInteger类:</p> <pre> <code class="language-java">package xqlee.net.project.demo.thread.synchronize; import java.util.concurrent.atomic.AtomicInteger; public class ForTest2 { public static AtomicInteger count = new AtomicInteger(0); public static void main(String[] args) { // 开启两个线程 for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(10); } catch (Exception e) { e.printStackTrace(); } //每个线程累计加100 for (int j = 0; j < 100; j++) { count.incrementAndGet(); // System.out.println(count); } } }).start(); } try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } System.out.println("count=" + count); } } </code></pre> <br /> 演示执行结果:<br /> <img alt="原子操作类进行乐观锁" class="img-thumbnail" src="/assist/images/blog/be44242a5e9340abbe97aa8cd621a55f.png" /><br /> 使用AtomicInteger之后,最终的输出结果同样可以保证是200。并且在<strong>某些情况下</strong>,代码的性能会比Synchronized更好。<br /> <br /> 那么Atomic操作类底层到底利用了什么手段呢?<br /> 其实Atomic就是用到了我们要讲的[CAS机制]<br />   <p><strong>什么是CAS?</strong></p> <p> </p> <p>CAS是英文单词<strong>Compare And Swap</strong>的缩写,翻译过来就是比较并替换。</p> <p> </p> <p>CAS机制当中使用了3个基本操作数:内存地址V,旧的预期值A,要修改的新值B。</p> <p>更新一个变量的时候,只有当变量的预期值A和内存地址V当中的实际值相同时,才会将内存地址V对应的值修改为B。</p> <p>这样说或许有些抽象,我们来看一个例子:</p> <p>1.在内存地址V当中,存储着值为10的变量。</p> <img alt="内存地址V" class="img-thumbnail" src="/assist/images/blog/9da6331c557f46d3ad148fe777a91e5a.png" /><br /> 2.此时线程1想要把变量的值增加1。对线程1来说,旧的预期值A=10,要修改的新值B=11。<br /> <img alt="内存地址V2" class="img-thumbnail" src="/assist/images/blog/761fcd40fb074a66915e845d08139997.png" /><br /> <br /> 3.在线程1要提交更新之前,另一个线程2抢先一步,把内存地址V中的变量值率先更新成了11。<br /> <br /> <img alt="内存地址V3" class="img-thumbnail" src="/assist/images/blog/e247329a723f45c39dd4db9f50b59122.png" /><br /> 4.线程1开始提交更新,首先进行<strong>A和地址V的实际值比较(Compare)</strong>,发现A不等于V的实际值,提交失败。<br /> <img alt="内存地址V4" class="img-thumbnail" src="/assist/images/blog/ea99b78cf5fa414fa481ff39437f310e.png" /><br /> 5.线程1重新获取内存地址V的当前值,并重新计算想要修改的新值。此时对线程1来说,A=11,B=12。这个重新尝试的过程被称为<strong>自旋</strong>。<br /> <br /> <img alt="内存地址V5" class="img-thumbnail" src="/assist/images/blog/f03a795b87884530a02d4247f2e1bd26.png" /><br /> 6.这一次比较幸运,没有其他线程改变地址V的值。线程1进行<strong>Compare</strong>,发现A和地址V的实际值是相等的。<br /> <br /> <img alt="内存地址6" class="img-thumbnail" src="/assist/images/blog/f1d8e07fac864ef9845aed9436d17c7f.png" /><br /> 7.线程1进行<strong>SWAP</strong>,把地址V的值替换为B,也就是12。<br /> <img alt="内存地址7" class="img-thumbnail" src="/assist/images/blog/c407d63f332043bc8c09f4582d66e6dc.png" /><br />     所以从思想上来说,Synchronized属于<strong>悲观锁</strong>,悲观地认为程序中的并发情况严重,所以严防死守。CAS属于<strong>乐观锁</strong>,乐观地认为程序中的并发情况不那么严重,所以让线程不断去尝试更新。<br /> <br /> 两种机制CAS机制和Synchronized,没有绝对的好坏。那么如何抉择呢?<br /> 在并发量非常搞的情况下使用Synchronized同步锁更适合一些。<br /> <br /> <strong>CAS缺点:</strong> <p><strong>1.CPU开销较大</strong></p> <p>在并发量比较高的情况下,如果许多线程反复尝试更新某一个变量,却又一直更新不成功,循环往复,会给CPU带来很大的压力。</p> <p><strong>2.不能保证代码块的原子性</strong></p> <p>CAS机制所保证的只是一个变量的原子性操作,而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新,就不得不使用Synchronized了。</p> <p><strong>3.ABA问题</strong></p> <p>这是CAS机制最大的问题所在。</p> <p>什么是<strong>ABA</strong>问题?怎么解决?我们后面来详细介绍。</p>
  • Java基础之class,Object,Class的区别

    Java中几个常见的基本元素class,Object,Class的区别说明<h2>1.Object</h2> 是一个特殊的类,所有的类都继承该类,包括Class也继承Object,也就说Class(注意Class大写)是Object的子类。且可以通过eclipse的关系树中看出<br /> <img alt="Class关系树" class="img-thumbnail" src="/assist/images/blog/5bb6f15a2ba54666a3b0c45ce5208fa6.png" /> <h2>2.Class</h2>   只是一个名字比较特殊的类,是关键字class修饰的类,一般应用于反射,只是名称比较特殊而已,可以通过Class类型来获取其他类型的元数据(metadata),比如字段,属性,构造器,方法等等,可以获取并调用。<strong><span style="color:#e74c3c">注意,Class不能直接通过new实例化,Object不是Class的实例</span></strong> <h2>3.class</h2> class是一个关键字,是用来修饰类 <h2>4.常见问题</h2> <span style="color:#e74c3c"><s>所有的类都是Class类的实例,Object是类,那么Object也是Class类的一个实例。</s></span><strong>(</strong><strong>错误的说法)</strong><br /> 所有的类都最终继承自Object类,Class是类,那么Class也继承自Object。<strong>(正确说法)</strong>
  • 一名3年工作经验的java程序员应该具备的技能

    一名3年工作经验的java程序员应该具备的技能<p>一名3年工作经验的Java程序员应该具备的技能,这可能是Java程序员们比较关心的内容。我这里要说明一下,以下列举的内容不是都要会的东西—-但是如果你掌握得越多,最终能得到的评价、拿到的薪水势必也越高。</p> <h2>1、基本语法</h2> <p>        这包括static、final、transient等关键字的作用,foreach循环的原理等等。今天面试我问你static关键字有哪些作 用,如果你答出static修饰变量、修饰方法我会认为你合格,答出静态块,我会认为你不错,答出静态内部类我会认为你很好,答出静态导包我会对你很满 意,因为能看出你非常热衷研究技术。</p> <p>        最深入的一次,我记得面试官直接问到了我Volatile关 键字的底层实现原理(顺便插一句,面试和被面试本身就是相对的,面试官能问这个问题同时也让面试者感觉到面试官也是一个喜爱研究技术的人,增加了面试者对 公司的好感,我最终选择的就是问了这个问题的公司),不要觉得这太吹毛求疵了—-越简单的问题越能看出一个人的水平,别人对你技术的考量绝大多数都是以深度优先、广度次之为标准的,切记。</p> <h2>2、集合</h2> <p>        非常重要,也是必问的内容。基本上就是List、Map、Set,问的是各种实现类的底层实现原理,实现类的优缺点。</p> <p>集合要掌握的是ArrayList、LinkedList、Hashtable、HashMap、ConcurrentHashMap、 HashSet的实现原理,能流利作答,当然能掌握CopyOnWrite容器和Queue是再好不过的了。另外多说一 句,ConcurrentHashMap的问题在面试中问得特别多,大概是因为这个类可以衍生出非常多的问题,关于ConcurrentHashMap, 我给网友朋友们提供三点回答或者是研究方向:</p> <p>(1)ConcurrentHashMap的锁分段技术。</p> <p>(2)ConcurrentHashMap的读是否要加锁,为什么。</p> <p>(3)ConcurrentHashMap的迭代器是强一致性的迭代器还是弱一致性的迭代器。</p> <h2>3、框架</h2> <p>        老生常谈,面试必问的东西。一般来说会问你一下你们项目中使用的框架,然后给你一些场景问你用框架怎么做,比如我想要在Spring初始化bean 的时候做一些事情该怎么做、想要在bean销毁的时候做一些事情该怎么做、MyBatis中$和#的区别等等,这些都比较实际了,平时积累得好、有多学习 框架的使用细节自然都不成问题。</p> <p>        如果上面你的问题答得好,面试官往往会深入地问一些框架的实现原理。问得最多的就是Spring AOP的实现原理,当然这个很简单啦,两句话就搞定的的事儿,即使你不会准备一下就好了。我遇到的最变态的是让我画一下Spring的Bean工厂实 现的UML图,当然面对这样一个有深度的问题,我是绝对答不出来的/(ㄒoㄒ)/~~</p> <h2>4、数据库</h2> <p>        数据库十有八九也都会问到。一些基本的像和 all的区别、left join、几种索引及其区别就不谈了,比较重要的就是数据库性能的优化,如果对于数据库的性能优化一窍不通,那么有时间,还是建议你在面试前花一两天专门 把SQL基础和SQL优化的内容准备一下。</p> <p>        不过数据库倒是不用担心,一家公司往往有很多部门,如果你对数据库不熟悉而基本技术又非常好,九成都是会要你的,估计会先把你放到对数据库使用不是要求非常高的部门锻炼一下。</p> <h2>5、Web方面的一些问题</h2> <p>Java主要面向Web端,因此Web的一些问题也是必问的。</p> <p>我碰到过问得最多的两个问题是:</p> <p>谈谈分布式Session的几种实现方式。(大家可以聊下你们知道的实现方法)</p> <p>常用的四种能答出来自然是让面试官非常满意的。</p> <p>另外一个常问的问题是:讲一下Session和Cookie的区别和联系以及Session的实现原理。这两个问题之外,web.xml里面的内容是重点,Filter、Servlet、Listener,不说对它们的实现原理一清二楚吧,至少能对它们的使用知根知底。另外,一些细节的方面比如get/post的区别、forward/重定向的区别、HTTPS的实现原理也都可能会被考察到。</p> <h2>6、数据结构和算法分析</h2> <p>        数据结构和算法分析,对于一名程序员来说,会比不会好而且在工作中绝对能派上用场。数组、链表是基础,栈和队列深入一些但也不难,树挺重要的,比较 重要的树AVL树、红黑树,可以不了解它们的具体实现,但是要知道什么是二叉查找树、什么是平衡树,AVL树和红黑树的区别。记得某次面试,某个面试官和 我聊到了数据库的索引,他问我:你知道索引使用的是哪种数据结构实现吗?</p> <p>我答到用的Hash表吧,答错。他又问,你知道为什么要使用树吗?我答到因为Hash表可能会出现比较多的冲突,在千万甚至是上亿级别的数据面 前,会大大增加查找的时间复杂度。而树比较稳定,基本保证最多二三十次就能找到想要的数据,对方说不完全对,最后我们还是交流了一下这个问题,我也明白了 为什么要使用树,这里不说,网友朋友们觉得索引为什么要使用树来实现呢?</p> <p>至于算法分析,不会、不想研究就算了,记得某次面试对方问我,Collections.sort方法使用的是哪种排序方法,额,吐血三升。当然为了 显示我的博学,对算法分析也有一定的研究(⊙﹏⊙)b,我还是硬着头皮说了一句可能是冒泡排序吧。当然答案肯定不是,有兴趣的网友朋友们可以去看一下 Collections.sort方法的源代码,用的是一种叫做TimSort的排序法,也就是增强型的归并排序法。</p> <h2>7、Java虚拟机</h2> <p>        出乎我的意料,Java虚拟机应该是很重要的一块内容,结果在这几家公司中被问到的概率几乎为0。要知道,我去年可是花了大量的时间去研究Java虚拟机的,光周志明老师的《深入理解Java虚拟机:JVM高级特性与最佳实践》,我就读了不下五遍。</p> <p>        言归正传,虽然Java虚拟机没问到,但我觉得还是有必要研究的,我就简单地列一个提纲吧,谈谈Java虚拟机中比较重要的内容:</p> <p>(1)Java虚拟机的内存布局</p> <p>(2)GC算法及几种垃圾收集器</p> <p>(3)类加载机制,也就是双亲委派模型</p> <p>(4)Java内存模型</p> <p>(5)happens-before规则</p> <p>(6)volatile关键字使用规则</p> <p>也许面试无用,但在走向大牛的路上,不可不会。</p> <h2>8、设计模式</h2> <p>        本来以为蛮重要的一块内容,结果只在阿里巴巴B2B事业部面试的时候被问了一次,当时问的是装饰器模式。</p> <p>        当然咱们不能这么功利,为了面试而学习,设计模式在工作中还是非常重要、非常有用的,23种设计模式中重点研究常用的十来种就可以了,面试中关于设计模式的问答主要是三个方向:</p> <p>(1)你的项目中用到了哪些设计模式,如何使用。</p> <p>(2)知道常用设计模式的优缺点。</p> <p>(3)能画出常用设计模式的UML图。</p> <h2>9、多线程</h2> <p>        这也是必问的一块了。因为三年工作经验,所以基本上不会再问你怎么实现多线程了,会问得深入一些比如说Thread和Runnable的区别和联 系、多次start一个线程会怎么样、线程有哪些状态。当然这只是最基本的,出乎意料地,几次面试几乎都被同时问到了一个问题,问法不尽相同。</p> <p>总结起来是 这么一个意思:</p> <p>        假如有Thread1、Thread2、ThreaD3、Thread4四条线程分别统计C、D、E、F四个盘的大小,所有线程都统计完毕交给Thread5线程去做汇总,应当如何实现?</p> <p>        聪明的网友们对这个问题是否有答案呢?不难,java.util.concurrent下就有现成的类可以使用。(大家可以留言讨论下用的什么方法实现)</p> <p>        另外,线程池也是比较常问的一块,常用的线程池有几种?这几种线程池之间有什么区别和联系?线程池的实现原理是怎么样的?实际一些的,会给你一些具体的场景,让你回答这种场景该使用什么样的线程池比较合适。</p> <p>最后,虽然这次面试问得不多,但是多线程同步、锁这块也是重点。synchronized和ReentrantLock的区别、 synchronized锁普通方法和锁静态方法、死锁的原理及排查方法等等。</p> <h2>10、JDK源码</h2> <p>        要想拿高工资,JDK源码不可不读。上面的内容可能还和具体场景联系起来,JDK源码就是实打实地看你平时是不是爱钻研了。我面试过程中被问了不 少JDK源码的问题,其中最刁钻的一个问了我,String的hashCode()方法是怎么实现的,幸好我平时String源代码看得多,答了个大 概。</p> <p>JDK源码其实没什么好总结的,纯粹看个人,总结一下比较重要的源码:</p> <p>(1)List、Map、Set实现类的源代码</p> <p>(2)ReentrantLock、AQS的源代码</p> <p>(3)AtomicInteger的实现原理,主要能说清楚CAS机制并且AtomicInteger是如何利用CAS机制实现的</p> <p>(4)线程池的实现原理</p> <p>(5)Object类中的方法以及每个方法的作用</p> <p>        这些其实要求蛮高的,我去年一整年基本把JDK中重要类的源代码研究了个遍,真的花费时间、花费精力,当然回头看,是值得的—-不仅仅是为了应付面试。</p> <p>        最后,如果有兴趣有时间,建议学习、研究一下SOA和RPC,面向服务体系,大型分布式架构必备,救命良方、包治百病、屡试不爽。</p>
  • Python教程-Python中的变量

    了解python中的变量,声明局部变量和全局变量了解python中的变量,声明局部变量和全局变量。另外,了解python函数内部使用的全局关键字。​1.创建变量1.1。简单分配Python语言没有用于声明变量的关键字。当我们首先为变量赋值时,会立即在适当位置创建一个变量。创建变量:i = 20 blogName = "leftso" print(i) # prints 20 print(blogName) # prints leftso可以使用单引号和双引号来创建字符串类型的变量。$title(String类型) author = 'Lokesh' blogName = "leftso" print(author) # prints Lokesh print(blogName) # prints leftso1.2。连锁分配Python还允许使用链式分配,这使得可以将相同的值同时分配给多个变量。i = j = k = 20 print(i) # prints 20 print(j) # prints 20 print(k) # prints 201.3。单行中的多个分配Python允许您在一行中将值分配给多个变量。x, y, z = "A", "B", 100 print(x) # prints A print(y) # prints B print(z) # prints 1001.2。变量重新声明由于变量不需要数据类型信息,因此我们可以毫无问题地重新分配任何类型的新值。在Python中,可以为变量分配一种类型的值,然后在以后重新分配其他类型的值。$title(变量重申明) index = 10 index = 20 index = "NA" print(index) # prints NA2.命名规范在Python中创建变量的规则是:变量名必须以字母或下划线字符开头。变量名不能以数字开头。变量名称只能包含字母数字字符和下划线 (A-z, 0-9, and _ )。变量名称区分大小写。例如,name, Name 和 NAME是三个不同的变量。注意: Python 3具有完整的Unicode支持,它也允许在变量名中使用Unicode字符。3.局部变量与全局变量3.1。创建局部变量和全局变量在函数内部创建的变量称为局部变量。在函数外部创建的变量是全局变量。全局变量可以被函数内部和外部的每个人使用。x = 10 # 全局变量 def myfunc(): y = 10 # 局部变量 print("Sum of x and y = " + str(x + y)) # prints Sum of x and y = 20 myfunc() print("Sum of x and y = " + str(x + y)) # NameError: name 'y' is not defined3.2。局部变量限制在函数范围内如果在函数内部创建具有相同名称的变量,则该变量将是局部变量,并且只能在函数内部使用。具有相同名称的全局变量将保留原样,并具有原始值。x = 10 # 全局变量 def myfunc(): x = 20 # 局部变量 print("x is " + str(x)) # prints x is 20 myfunc() print("x is " + str(x)) # prints x is 103.3。'global'关键字要在函数内部创建全局变量,可以使用global关键字。x = 10 # 全局变量 def myfunc(): global y y = 10 # 在函数内部创建的全局变量 print("Sum of x and y = " + str(x + y)) # prints Sum of x and y = 20 myfunc() print("Sum of x and y = " + str(x + y)) # prints Sum of x and y = 20Python变量 图像 小部件
  • apache 24 配置301跳转 解决cdn问题

    apache 24 配置301跳转 解决cdn问题<IfModule rewrite_module> Options +FollowSymLinks RewriteEngine on RewriteCond Host: ^localhost$ #RedirectMatch 301 /static/(.*) http\://cdn\.icdicn\.com/static/$1 RedirectMatch 301 /static/img/(.*) http\://cdn\.icdicn\.com/static/img/$1 RedirectMatch 301 /static/echarts\.min\.js http\://cdn\.icdicn\.com/static/echarts\.min\.js RedirectMatch 301 /static/public-framework\.js http\://cdn\.icdicn\.com/static/public-framework\.js </IfModule>​​​​​​​代码段 小部件