「java易变的」java近几年发展变化

admin 2023-03-18 05:15:06 594

本篇文章给大家谈谈java易变的，以及java近几年发展变化对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java多线程开发的同步机制有哪些
2、Java：volatile的作用是什么呢？我的理解正确吗？
3、JAVA 里static 和volatile的区别
4、如何从java小白快速变成java大神呢？

java多线程开发的同步机制有哪些

Java同步

标签：分类：

一、关键字：

thread（线程）、thread-safe(线程安全)、intercurrent（并发的）

synchronized(同步的)、asynchronized(异步的)、

volatile（易变的）、atomic（原子的）、share（共享）

二、总结背景：

一次读写共享文件编写，嚯，好家伙，竟然揪出这些零碎而又是一路的知识点。于是乎，Google和翻阅了《Java参考大全》、《Effective Java Second Edition》，特此总结一下供日后工作学习参考。

三、概念：

1、什么时候必须同步？什么叫同步？如何同步？

要跨线程维护正确的可见性，只要在几个线程之间共享非 final 变量，就必须使用 synchronized（或 volatile）以确保一个线程可以看见另一个线程做的更改。

为了在线程之间进行可靠的通信，也为了互斥访问，同步是必须的。这归因于java语言规范的内存模型，它规定了：一个线程所做的变化何时以及如何变成对其它线程可见。

因为多线程将异步行为引进程序，所以在需要同步时，必须有一种方法强制进行。例如：如果2个线程想要通信并且要共享一个复杂的数据结构，如链表，此时需要

确保它们互不冲突，也就是必须阻止B线程在A线程读数据的过程中向链表里面写数据（A获得了锁，B必须等A释放了该锁）。

为了达到这个目的，java在一个旧的的进程同步模型——监控器（Monitor）的基础上实现了一个巧妙的方案：监控器是一个控制机制，可以认为是一个

很小的、只能容纳一个线程的盒子，一旦一个线程进入监控器，其它的线程必须等待，直到那个线程退出监控为止。通过这种方式，一个监控器可以保证共享资源在

同一时刻只可被一个线程使用。这种方式称之为同步。（一旦一个线程进入一个实例的任何同步方法，别的线程将不能进入该同一实例的其它同步方法，但是该实例

的非同步方法仍然能够被调用）。

错误的理解：同步嘛，就是几个线程可以同时进行访问。

同步和多线程关系：没多线程环境就不需要同步;有多线程环境也不一定需要同步。

锁提供了两种主要特性：互斥（mutual exclusion）和可见性（visibility）。

互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。

可见性要更加复杂一些，documents它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题

小结：为了防止多个线程并发对同一数据的修改，所以需要同步，否则会造成数据不一致（就是所谓的：线程安全。如java集合框架中Hashtable和

Vector是线程安全的。我们的大部分程序都不是线程安全的，因为没有进行同步，而且我们没有必要，因为大部分情况根本没有多线程环境）。

2、什么叫原子的（原子操作）？

Java原子操作是指：不会被打断地的操作。（就是做到互斥和可见性？！）

那难道原子操作就可以真的达到线程安全同步效果了吗？实际上有一些原子操作不一定是线程安全的。

那么，原子操作在什么情况下不是线程安全的呢？也许是这个原因导致的：java线程允许线程在自己的内存区保存变量的副本。允许线程使用本地的私有拷贝进

行工作而非每次都使用主存的值是为了提高性能（本人愚见：虽然原子操作是线程安全的，可各线程在得到变量（读操作）后，就是各自玩

弄自己的副本了，更新操作（写操作）因未写入主存中，导致其它线程不可见）。

那该如何解决呢？因此需要通过java同步机制。

在java中，32位或者更少位数的赋值是原子的。在一个32位的硬件平台上，除了double和long型的其它原始类型通常都

是使用32位进行表示，而double和long通常使用64位表示。另外，对象引用使用本机指针实现，通常也是32位的。对这些32位的类型的操作是原

子的。

这些原始类型通常使用32位或者64位表示，这又引入了另一个小小的神话：原始类型的大小是由语言保证的。这是不对的。java语言保证的是原始类型的表

数范围而非JVM中的存储大小。因此，int型总是有相同的表数范围。在一个JVM上可能使用32位实现，而在另一个JVM上可能是64位的。在此再次强

调：在所有平台上被保证的是表数范围，32位以及更小的值的操作是原子的。

3、不要搞混了：同步、异步

举个例子：普通B/S模式（同步）AJAX技术（异步）

同步：提交请求-等待服务器处理-处理完返回这个期间客户端浏览器不能干任何事

异步：请求通过事件触发-服务器处理（这是浏览器仍然可以作其他事情）-处理完毕

可见，彼“同步”非此“同步”——我们说的java中的那个共享数据同步（synchronized）

一个同步的对象是指行为（动作），一个是同步的对象是指物质（共享数据）。

4、 Java同步机制有4种实现方式：（部分引用网上资源）

① ThreadLocal ② synchronized( ) ③ wait() 与 notify() ④ volatile

目的：都是为了解决多线程中的对同一变量的访问冲突

ThreadLocal

ThreadLocal 保证不同线程拥有不同实例，相同线程一定拥有相同的实例，即为每一个使用该变量的线程提供一个该变量值的副本，每一个线程都可以独立改变自己的副本，而不是与其它线程的副本冲突。

优势：提供了线程安全的共享对象

与其它同步机制的区别：同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信；而 ThreadLocal 是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源，这样当然不需要多个线程进行同步了。

volatile

volatile 修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。

优势：这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

缘由：Java

语言规范中指出，为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原

始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而 volatile

关键字就是提示 VM ：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用技巧：在两个或者更多的线程访问的成员变量上使用 volatile 。当要访问的变量已在 synchronized 代码块中，或者为常量时，不必使用。

线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步，因此存在A和B不一致

的情况。volatile就是用来避免这种情况的。

volatile告诉jvm，它所修饰的变量不保留拷贝，直接访问主内存中的（读操作多时使用较好；线程间需要通信，本条做不到）

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile

变量的最新值。Volatile

变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值

之间没有约束。

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。

sleep() vs wait()

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

（如果变量被声明为volatile，在每次访问时都会和主存一致；如果变量在同步方法或者同步块中被访问，当在方法或者块的入口处获得锁以及方法或者块退出时释放锁时变量被同步。）

Java：volatile的作用是什么呢？我的理解正确吗？

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1）. 并行设备的硬件寄存器（如：状态寄存器）

2）. 一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)

3）. 多线程应用中被几个任务共享的变量

这是区分C程序员和嵌入式系统程序员的最基本的问题：嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所有这些都要求使用volatile变量。不懂得volatile内容将会带来灾难。

假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是真正懂得volatile完全的重要性。

1）. 一个参数既可以是const还可以是volatile吗？解释为什么。

2）. 一个指针可以是volatile 吗？解释为什么。

3）. 下面的函数被用来计算某个整数的平方，它能实现预期设计目标吗？如果不能，试回答存在什么问题：

int square( volatile int *ptr )

{

return *ptr * *ptr;

}

下面是答案：

1）. 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2）. 是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

3）. 这段代码是个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square( volatile int *ptr )

{

int a,b;

a = *ptr;

b = *ptr;

return a * b;

}

由于*ptr的值可能在两次取值语句之间发生改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！正确的代码如下：

long square( volatile int *ptr )

{

int a;

a = *ptr;

return a * a;

}

讲讲个人理解：

关键在于两个地方：

⒈编译器的优化（请高手帮我看看下面的理解）

在本次线程内，当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后再取变量值时，就直接从寄存器中取值；

当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致

举一个不太准确的例子：

发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资

员工－－原始变量地址

银行卡号－－原始变量在寄存器的备份

⒉ 在什么情况下会出现

1）. 并行设备的硬件寄存器

2）. 一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)

3）. 多线程应用中被几个任务共享的变量

补充：volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；

“易变”是因为外在因素引起的，像多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；

而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了；大家看看前面那种解释（易变的）是不是在误导人

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

使用该关键字的例子如下：

int volatile nVint;

当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：

volatile int i=10;

int a = i;

// ...

//其他代码，并未明确告诉编译器，对i进行过操作

int b = i;

volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样一来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：

首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：

#include stdio.h

void main( int argc, char * argv[] )

{

int i = 10;

int a = i;

printf( "i= %d", a );

//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道

__asm

{

mov dword ptr [ebp-4], 20h

}

int b = i;

printf( "i= %d", b );

}

然后，在调试版本模式运行程序，输出结果如下：

i = 10

i = 32

然后，在release版本模式运行程序，输出结果如下：

i = 10

输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：

#include stdio.h

void main( int argc, char * argv[] )

{

volatile int i=10;

int a = i;

printf( "i= %d", a );

__asm

{

mov dword ptr [ebp-4], 20h

}

int b = i;

printf( "i= %d", b );

}

分别在调试版本和release版本运行程序，输出都是：

i = 10

i = 32

这说明这个关键字发挥了它的作用！

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

volatile对应的变量可能在你的程序本身不知道的情况下发生改变

比如多线程的程序，共同访问的内存当中，多个程序都可以操纵这个变量

你自己的程序，是无法判定何时这个变量会发生变化

还比如，他和一个外部设备的某个状态对应，当外部设备发生操作的时候，通过驱动程序和中断事件，系统改变了这个变量的数值，而你的程序并不知道。

对于volatile类型的变量，系统每次用到他的时候都是直接从对应的内存当中提取，而不会利用cache当中的原有数值，以适应它的未知何时会发生的变化，系统对这种变量的处理不会做优化——显然也是因为它的数值随时都可能变化的情况。

JAVA 里static 和volatile的区别

static也是各个业务方可以去全局修改；

volatile是处理多线程锁的替代方案，对应有时需要实时的修改共享资源的变量，被volatile修复的变量的值可以立刻被业务方取得最新的值。

变量放在主存区上，使用该变量的每个线程，都将从主存区拷贝一份到自己的工作区上进行操作。

volatile, 声明这个字段易变（可能被多个线程使用），Java内存模型负责各个线程的工作区与主存区的该字段的值保持同步，即一致性。

static, 声明这个字段是静态的（可能被多个实例共享），在主存区上该类的所有实例的该字段为同一个变量，即唯一性。

volatile, 声明变量值的一致性；static,声明变量的唯一性。

此外，volatile同步机制不同于synchronized, 前者是内存同步，后者不仅包含内存同步（一致性），且保证线程互斥（互斥性）。

static 只是声明变量在主存上的唯一性，不能保证工作区与主存区变量值的一致性；除非变量的值是不可变的，即再加上final的修饰符，否则static声明的变量，不是线程安全的。

下面摘自Java语言规范(Java Language Specification)的官方解释：

1) If a field is declared static, there exists exactly one incarnation of the field, no matter how many instances (possibly zero) of the class may eventually be created.

2) A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable。

如何从java小白快速变成java大神呢？

不想当厨师的学徒不是好学徒，不想当老板的员工不是好员工，不想开花结果的恋爱都是耍流氓。不想当java大神的学员不是好学员，学习java，就是为了提高自己的java技术，所以如何从java小白变成java大神呢？

1.合理安排时间，花时间专注于写代码

有人说这还不容易吗?我每天的工作就是写代码，花的时间远远是你想不到的。其实，问问你自己真的在写代码时全身心的投入进去了吗?没有把时间花在开会、喝茶、聊天、吃饭上吗?

有人又说，在职场身不由己。对。在职场是很难把时间纯粹花在写代码上。这也是很多程序员讨厌在工作中被人打扰的原因。所以，建议你，合理安排自己的时间，花时间专注于写代码，提高你自身的技能。

2.配合开发团队，善于从团队成员中学习新东西

作为开发团队中的一员，你必须与你的开发团队中的其他成员一起共事，无论你的个性有多么独特突出。俗话说的好，“三人行必有我师焉”，你配合好开发团队的工作，你就会从开发团队其他成员中学习到很多不一样的东西，并且，团队氛围其乐融融，你工作也会乐在其中，外界干扰因素也会大大减少。

3.敢于挑战新的开发团队，离开长期相同的工作

Java小白在一个开发团队待久了，慢慢的工作中所需要的技能都掌握了，那么就会陷入到一个死胡同，每天都是相同的工作，技能真的很难得到新的提升。这时候找家新的开发团队就很重要，既可以保持自己编程的活力，又可以从新的开发团队身上学习新的内容。所以，敢于挑战新的开发团队，离开长期相同的工作，也是你挑战自己新的开始。

4.学习java永无止境

学习java无止境，当下软件技术更新的日新月异，每天无数编程技能在你还未察觉的时候就已经被淘汰，所以你想要在java领域长期发展，北大青鸟认为你就必须时时刻刻关注新的编程语言和技术趋势，不要满足于当下你java学的多么牛，要保持如饥似渴的态度和持续的激情，永无止境的学习java。

java易变的的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java近几年发展变化、java易变的的信息别忘了在本站进行查找喔。

标签：java易变的