Concurrente Java conocimientos de programación para aprender a principios del próximo
Anterior a través de "conocimiento simultáneo de programación Java en el capítulo de aprendizaje temprano," Sabemos lo que la visibilidad en Java concurrencia es? La definición de volátiles y la definición de JMM. Vamos a echar un vistazo a algunas preguntas cara fabricantes de bienes:
editar
editar
editar
A partir de varias preguntas de la entrevista real de lo anterior, podemos ver que el fabricante de la entrevista le hará preguntas relacionadas con la concurrencia. tan
concurrencia de Java, si se trata de esta entrevista o en el trabajo, complicado por todo el encuentro. Java y contraer JUC (java.util.concurrent) que averiguar de qué? Y lo que es más importante es lograr un contrato? El principio es que usted sabe qué? ¿Cuál es la visibilidad de la JMM? volatiile variable clave es cómo lograr la visibilidad? Si quieres aprender concurrencia, entendemos entender a fondo las palabras, Kaige se sienta menos conocimiento de la computadora o aprender a comprender. La "Programación Java concurrente - el conocimiento de preparación" Kaige listo para usar dos informes, incluyendo lo siguiente: a la visibilidad de memoria breve de palabras clave entre lo que es volátil en la especificación del lenguaje Java se define cómo ?? Pero usted sabe lo que sabe JVM JMM no es así? La CPU del ordenador es cómo hacer frente a los datos? Los datos procesados por la CPU para una comprensión profunda de la visibilidad entre los hilos. No es volátil es la forma de garantizar la visibilidad de la misma? ¿Cuáles son dos principios que logran?
conocimientos relacionados con la CPU
Echemos un vistazo a la configuración del equipo Kaige:
editar
editar
editar
A partir del gráfico, se puede ver el ordenador Kaige
procesamiento 4-núcleo de la CPU es de 8 hilos,
Hay tres niveles de caché.
En donde una caché de instrucciones y caché de datos son 32K,
256K caché secundaria,
caché de tres niveles es 6M.
La memoria de computadora es 24G
¿Por qué decir esto?
因为JVM运行程序的实体其实就是线程，而每个线程在创建的时候JVM都会给其创建一个工作内存（有些地方称之为：栈空间）。工作内存是每个线程自己的私有数据区域。Java内存模型中规定所有的变量都是存储在主内存中(也就是凯哥24G内内存中)，主内存是共享内存区域，所有的线程都可以访问的(也就是说主内存中的数据，任意线程都可以访问)。但是线程对变量的操作，如读取，修改赋值操作是在从中内存中进行的。因此，一个线程要想操作一个变量，首先是要讲变量从主内存copy到自己的工作内存空间，然后再对自己工作空间中对变量操作，操作完成之后再将变量写回到主内存中去。线程是不能够直接操作主内存中的变量的。各个线程中的工作内存存储的其实就是主内存的一个变量副本拷贝。因此不同线程之间是无法访问到对方的工作内存的。线程间的通讯(值转递)必须通过主内存来完成的。
上面这么大一段话，可以简单对应凯哥电脑配置：
线程：其实就是凯哥CPU的4核8线程中的线程
主内存：就是凯哥本子上的24G物理内存条
线程工作内存空间：就是缓存(一二三级缓存区域)
线程工作原理，如下图：
编辑
说明：
主内存中变量int i= 0；
cpu1中的线程1获取到i变量的时候，会将i从主内存中copy一份到自己的工作区域，也就是cpu1 cache中，然后更新i的值为10；
cpu2中的线程2同样获取到i变量，从主内存中copy一份之后，在自己的工作区cpu2 cache中将i修改成了15；这种情况下就是多核多线程问题。
线程之间可见性深度理解
在这种情况下主内存中的i就是两个线程之间的共享变量了。那么怎么能确保cpu1的线程1修改i的值之后，通知cpu2中的线程2的工作区缓存无效呢？这个操作就是线程之间的可见性。
再举个现实生活中常用的例子：
比如，凯哥现在在和大家分享。今天我发布之后，你们大家在自己手机或者是PC网友上都能看到凯哥分享的知识点。这个时候有个网友A在看到凯哥分享的东西，感觉有点不好或者是举个其他的例子或者更容易理解。于是他把凯哥这个文章进行了修改。然后给凯哥留Y。告诉凯哥，凯哥看后，觉得很不错。等明天，凯哥发文章通知大家，如果用xxx的案例就跟容易让大家理解了。于是，你们大家知道，哦原来昨天的案例不是最新的了。放弃昨天的，看看今天最新的案例。
如果上面案例看着是多线程那么可以这么分析：
主内存：凯哥
共享变量：凯哥分享的知识点
多个线程：各位看凯哥分享的网友
其中网友A修改了知识点的内容(网友A修改的是自己手机上的(工作区的)知识点)后通知了凯哥，然后凯哥又通知了各位。各位知道原来自己手里的不是最新的了，然后放弃重新获取最新的。
这样来理解的话，就更容易理解线程的可见性
Volatitle是如何保证可见性的呢？
可以通过JIT编译器生成的汇编指令来查看对volatile进行写操作时候，CPU都做了哪些事情？
如下代码：
Volatile Singleton instance = new Singleton();
Instance是被volatitle修饰的。
在使用JIT编译器生成的汇编指令后，有一个重要的代码：
0x01a2de1d:xxxx:lock addl $0X0,(%esp);
我们可以看到，当一个共享变量被volatile修饰之后，在进行写操作的时候，会多出一些汇编代码Lock.在IA-32架构软件开发手册中，Lock前缀的指令当在多核处理器的时候会引发出两件事情：
1：将当前的处理器缓存行的数据写回的主内存中(也就是系统的物理缓存中)；
2：同时这个写回内存的操作也会使其他CUP里缓存了内存地址的数据被置为无效。
Cpu处理数据方法：
为了提高处理数据，CPU不会直接从内存中获取数据操作的。
Aquí necesitamos una velocidad de procesamiento informático de clasificación de datos: Disco (HDD) <Memoria <cache <CPU. Podemos ver que la velocidad de funcionamiento de la CPU es mucho más rápido que la memoria. Por lo tanto, si la CPU acceso directo a la memoria no sólo afectará a la velocidad de procesamiento de la memoria es también posible para hacer la vida más corta. Esta vez, la memoria caché va a resolver este problema.
Por lo tanto, la CPU de procesamiento de datos será como caducan caché de datos en memoria a avanzado (es decir, ciento veinte y-caché de tres), y luego el funcionamiento de la memoria caché.
Cuando los procesadores multi-núcleo, con el fin de garantizar las variables de caché entre cada procesador es el mismo, tenemos que aplicar el protocolo de coherencia de caché. Su funcionamiento es el siguiente: cada CPU por oler los datos que viajan en el autobús para comprobar el valor de su propio almacenamiento en caché en tiempo real no está ya expiró. Si se emite sus propios datos en la caché se ha modificado, será el estado de los datos de la caché del procesador actual a inactivo, cuando el procesador necesita para operar en estos datos parece, lo hará de nuevo desde la memoria principal, para leer los datos más recientes en su propia caché.
Volátiles dos principios de implementación
1: instrucciones de montaje de prefijo de bloqueo de código hacen que el caché del procesador es de nuevo a la memoria principal escritos.
Cuando hay una instrucción de bloqueo caché, durante el cual PRoFESS puede hacer para asegurar que el procesador puede monopolizar cualquier memoria compartida. coherencia de caché al mismo tiempo evitar que dos o más modificado por el área de memoria de datos de la caché del procesador
2: Cuando la memoria caché de un procesador se escribe de nuevo a la memoria principal, que dará lugar a otra caché del procesador no es válido
Este es un procesador de protocolo de control común para mantener caché interna
resumen:
Por estos dos "Java concurrencia conocimiento preparatorio" de entendimiento, sabemos que los datos de intercambio de conocimientos entre JMM, hilo, por lo que entonces el siguiente aprendizaje de Java programación concurrente será un simple. Siguiente Bienvenido al aprendizaje de Java concurrencia!
editar