java图形界面设计实例，2021最新版！

柔光的暖阳◎ 2021-07-20 21:51 373阅读 0赞

![1cf25dfb8f94a9c366548c0ac32932ad.png][]

> 今年互联网形式依旧严峻，再次爆发几次大规模裁员潮。我决定把这篇文章分享出来帮助那些对前途感到迷茫的朋友。

在猎头的眼里，我已不是根正苗红的程序员。何为根正苗红？计算机专业毕业，从毕业起就从事特定方向的开发工作，这才是猎头眼中的香饽饽。

毕业之后的那段岁月，可以用悲惨形容，每当和人提起，我总会有点自嘲的说“睡过凌晨一点的办公室，吃过凌晨三点的便利店，做过凌晨五点的首班车”。但是回头想想，我却要感谢那不堪的经历，让我找到了适合自己的方向。

作为技术人员，我一直有个疑问，什么是你引以为傲的资本？面对已经来临的资本寒冬，应该何去何从？

大学期间，我每年都会给自己总结一个词语。回首做技术的这几年，我同样给自己总结了几个关键词。希望大家可以从中受益。

# 并发编程三大特性 #

## 原子性 ##

一个操作或者多次操作，要么所有的操作全部都得到执行并且不会受到任何因素的干扰而中断，**要么所有的操作都执行，要么都不执行**。

对于基本数据类型的访问，读写都是原子性的【long和double可能例外】。

如果需要更大范围的原子性保证，可以使用synchronized关键字满足。

## 可见性 ##

当一个变量对共享变量进行了修改，**另外的线程都能立即看到修改后的最新值**。

`volatile`保证共享变量可见性，除此之外，`synchronized`和`final`都可以 实现可见性。

`synchronized`：对一个变量执行unclock之前，必须先把此变量同步回主内存中。

`final`：被final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把this的引用传递出去，其他线程中就能够看见final字段的值。

## 有序性 ##

即程序执行的顺序按照代码的先后顺序执行【由于**指令重排序**的存在，Java 在编译器以及运行期间对输入代码进行优化，代码的执行顺序未必就是编写代码时候的顺序】，`volatile`通过禁止指令重排序保证有序性，除此之外，`synchronized`关键字也可以保证有序性，由【一个变量在同一时刻只允许一条线程对其进行lock操作】这条规则获得。

# CPU缓存模型是什么 #

## 高速缓存为何出现？ ##

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到**数据的读取和写入**。由于程序运行过程中的\*\*临时数据是存放在主存（物理内存）\*\*当中的，这时就存在一个问题，**由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多**，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。

为了解决CPU处理速度和内存不匹配的问题，CPU Cache出现了。

> 图源：JavaGuide

![079d220878b058c4b9d3c7413babb0dd.png][]

## 缓存一致性问题 ##

当程序在运行过程中，会**将运算需要的数据从主存复制一份到CPU的高速缓存当中**，那么CPU进行计算时就可以**直接从它的高速缓存读取数据和向其中写入数据**，当运算结束之后，再将高速缓存中的数据**刷新到主存**当中。

在单线程中运行是没有任何问题的，但是在多线程环境下问题就会显现。举个简单的例子，如下面这段代码：

i = i + 1;

按照上面分析，主要分为如下几步：

*  从主存读取i的值，复制一份到高速缓存中。
 *  CPU执行执行执行对i进行加1操作，将数据写入高速缓存。
 *  运算结束后，将高速缓存中的数据刷新到内存中。

**多线程环境**下，可能出现什么现象呢？

*  初始时，两个线程分别读取i的值，存入各自所在的CPU高速缓存中。
 *  线程T1进行加1操作，将i的最新值1写入内存。
 *  此时线程T2的高速缓存中i的值还是0，进行加1操作，并将i的最新值1写入内存。

> 最终的结果i = 1而不是i = 2，得出结论：**如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。**

## 如何解决缓存不一致 ##

解决缓存不一致的问题，通常来说有如下两种解决方案【都是在硬件层面上提供的方式】：

**通过在总线加LOCK\#锁的方式**

在早期的CPU当中，是通过在总线上加LOCK\#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK\#锁的话，也就是说阻塞了其他CPU对其他部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。比如上面例子中 如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了LCOK\#锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。

但，有一个问题，在锁住总线期间，其他CPU无法访问内存，导致效率低下，于是就出现了下面的缓存一致性协议。

**通过缓存一致性协议**

较著名的就是Intel的MESI协议，MESI协议保S证了每个缓存中使用的共享变量的副本是一致的。

**当CPU写数据时，如果发现操作的变量是共享变量**，即在其他CPU中也存在该变量的副本，会发出信号**通知其他CPU将该变量的缓存行置为无效状态**，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的【嗅探机制：每个处理器通过嗅探在总线上传播的数据来检查自己的缓存的值是否过期】，那么它就**会从内存重新读取**。

> 基于MESI一致性协议，每个处理器需要不断从主内存嗅探和CAS不断循环，无效交互会导致总线带宽达到峰值，出现**总线风暴**。

![2c5f6c8252335762acaa026cb2c242a9.png][]

# JMM内存模型是什么 #

`JMM【Java Memory Model】`：Java内存模型，是java虚拟机规范中所定义的一种内存模型，Java内存模型是标准化的，屏蔽掉了底层不同计算机的区别，以实现让Java程序在各种平台下都能达到**一致的内存访问效果**。

它描述了**Java程序中各种变量【线程共享变量】的访问规则**，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

> 注意，为了获得较好的执行性能，Java内存模型并没有限制执行引擎使用处理器的寄存器或者高速缓存来提升指令执行速度，也没有限制编译器对指令进行重排序。也就是说，在java内存模型中，也会存在**缓存一致性问题和指令重排序**的问题。

## JMM的规定 ##

**所有的共享变量都存储于主内存**，这里所说的变量指的是【实例变量和类变量】，不包含局部变量，因为**局部变量是线程私有的，因此不存在竞争问题**。

每个线程都有自己的**工作内存**（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。

每个线程不能访问其他线程的工作内存。

## Java对三大特性的保证 ##

### 原子性 ###

在Java中，**对基本数据类型的变量的读取和赋值操作是原子性操作**，即这些操作是不可被中断的，要么执行，要么不执行。

为了更好地理解上面这句话，可以看看下面这四个例子：

x = 10;  	//1
    y = x;   	//2
    x ++;    	//3
    x = x + 1;  //4

1.  只有语句1是原子性操作：直接将数值10赋值给x，也就是说线程执行这个语句的会**直接将数值10写入到工作内存中**。
2.  语句2实际包含两个操作：**先去读取x的值，再将x的值写入工作内存**，虽然两步分别都是原子操作，但是合起来就不能算作原子操作了。
3.  语句3和4表示：**先读取x的值，进行加1操作，写入新的值**。

需要注意的点：

*  在32位平台下，对64位数据的读取和赋值是需要通过两个操作来完成的，不能保证其原子性。在目前64位JVM中，已经保证对64位数据的读取和赋值也是原子性操作了。
 *  Java内存模型**只保证了基本读取和赋值是原子性操作**，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。

### 可见性 ###

Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会**保证修改的值会立即被更新到主存**，当有其他线程需要读取时，它会去内存中读取新值。

另外，**通过synchronized和Lock也能够保证可见性**，synchronized和Lock能保**证同一时刻只有一个线程获取锁然后执行同步代码**，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

### 有序性 ###

在Java内存模型中，允许编译器和处理器对指令进行**重排序**，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java里面，可以通过volatile关键字来保证有序性，另外也可以通过synchronized和Lock来保证有序性。

Java内存模型具备一些先天的有序性，前提是**两个操作满足happens-before原则**，摘自《深入理解Java虚拟机》：

*  程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作【让程序**看起来**像是按照代码顺序执行，虚拟机**只会对不存在数据依赖性的指令进行重排序**，只能保证单线程中**执行结果的正确性**，多线程结果正确性却无法保证】
 *  锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
 *  volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
 *  传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C
 *  线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作
 *  线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
 *  线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
 *  对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

# volatile解决的问题 #

*  保证了不同线程对共享变量【类的成员变量，类的静态成员变量】进行操作是时的可见性，**一个线程修改了某个变量的值，新值对其他线程来说是立即可见的**。
 *  禁止指令重排序。

举个简单的例子，看下面这段代码：

//线程1
    boolean volatile stop = false;
    while(!stop){
        doSomething();
    }
    //线程2
    stop = true;

1.  线程1和2各自都拥有自己的工作内存，线程1和线程2首先都会将stop变量的值拷贝一份放到自己的工作内存中，
2.  共享变量stop通过volatile修饰，线程2将stop的值改为true将会立即写入主内存。
3.  线程2写入主内存之后，导致线程1工作内存中缓存变量stop的缓存行无效。
4.  线程1的工作内存中缓存变量stop的缓存行无效，导致线程1会再次从主存中读取stop值。

# volatile保证原子性吗？怎么解决？ #

volatile无法保证原子性，如对一个volatile修饰的变量进行自增操作`i ++`，无法保证多线程下结果的正确性。

解决方法：

*  使用synchronized关键字或者Lock加锁，保证某个代码块 在同一时刻只能被一个线程执行。
 *  使用JUC包下的原子类，如AtomicInteger等。【Atomic利用CAS来实现原子操作】。

# volatile的实现原理 #

下面这段话摘自《深入理解Java虚拟机》：

> 观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。
> 
> lock前缀指令实际上相当于一个**内存屏障**（也成内存栅栏），内存屏障会提供3个功能：
> 
>  *  它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
>  *  它会强制将对缓存的修改操作立即写入主存；
>  *  如果是写操作，它会导致其他CPU中对应的缓存行无效。

# volatile和synchronized的区别 #

> volatile变量读操作的性能消耗与普通变量几乎没有什么差别，但是写操作则会慢一些，因为它需要在本地代码中**插入许多内存屏障指令**来保证处理器不发生乱序执行。不过即便如此，**大多数场景下volatile的总开销仍然要比锁来的低**。

*  volatile只能用于变量，而synchronized可以修饰方法以及代码块。
 *  volatile能保证可见性，但是不能保证原子性。synchronized两者都能保证。如果只是对一个共享变量进行多个线程的赋值，而没有其他的操作，推荐使用volatile，它更加轻量级。
 *  volatile 关键字主要用于解决变量在多个线程之间的可见性，而 synchronized 关键字解决的是多个线程之间访问资源的同步性。

# volatile的使用条件 #

使用volatile必须具备两个条件【保证原子】：

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

### 最后 ###

**对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。**

**整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。**

**再免费分享一波我的Java面试真题+视频学习详解+技能进阶书籍**

**[点击这里即可免费获取以上我收集整理的全部学习资料][Link 1]**

言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。\*\*

**整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。**

**再免费分享一波我的Java面试真题+视频学习详解+技能进阶书籍**

**[点击这里即可免费获取以上我收集整理的全部学习资料][Link 1]**

![美团二面惜败，我的凉经复盘（附学习笔记+面试整理+进阶书籍）][6ef36db3dcf746d33f217367af5f9a5a.png]

[1cf25dfb8f94a9c366548c0ac32932ad.png]: /images/20210720/81ee7b57dd9e425c8e2c947d5c38839b.png
[079d220878b058c4b9d3c7413babb0dd.png]: /images/20210720/c1641a9e27a3419889bb6ebd01ed3a62.png
[2c5f6c8252335762acaa026cb2c242a9.png]: /images/20210720/9ccb228eb4384e798b1b549ed5604916.png
[Link 1]: https://docs.qq.com/doc/DSmxTbFJ1cmN1R2dB
[6ef36db3dcf746d33f217367af5f9a5a.png]: /images/20210720/57cc813a529b4a6eb7de0865cd98c404.png