Java深入探索线程安全和线程通信的特性

一、线程安全（重点）

1、线程安全概念

在多线程的情况下，需要考虑多个线程并行并发执行：此时多个线程之间的代码是随机执行的。如果多线程环境下代码的运行结果是符合我们的预期的，即在单线程情况下应该的结果，则这个程序是线程安全的。

2、产生线程不安全的情况

多个线程共享变量的操作：

• 都是读操作时，使用值进行判断，打印等操作（不存在线程安全问题）
• 存在线程进行了写操作（存在线程安全问题）

3、线程不安全的原因

（1）原子性：多行指令是最小的执行单位（不可拆分），就具有原子性。如果不满足原子性，则存在线程安全问题。

一条java语句不一定是原子的：

• 如n++、n--，是有三步组成：从内存读取到cpu寄存器、修改数据、再写回到cpu；
• Object o=new Object()，也涉及到三个步骤：申请内存、初始化对象、赋值。

以上列举的虽然只是一条java语句，但是其不具有原子性。

（2）可见性：一个线程对共享变量的修改，能够及时的被其他线程看见。多个线程并发并行执行，使用各自的工作内存，互相之间不可见（不具有可见性）。

Java内存模型（JMM）：

目的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现Java程序在各种平台下都能达到一致的并发效果。

• 线程之间的共享变量存在主内存；
• 每一个线程都有自己的工作内存；
• 当程序要读取一个共享变量时，会先将变量从主内存拷贝到工作内存，再从工作内存读取数据；
• 当程序要修改一个共享变量时，会先修改工作内存中的副本，再同步到主内存。

（3）代码顺序性/有序性：

代码重排序：

比如，以下代码：

1、去前台取U盘，

2、回教室写一会作业，

3、去前台取快递

在单线程的情况下，JVM、cpu会对其进行优化，1→3→2，这样会提高效率，这样就叫做代码重排序。

代码重排序的前提是：保证逻辑不发生改变。

4、如何解决线程不安全问题

设计多线程代码原则：满足线程安全的前提下，尽可能地提高效率

（1）对共享变量的写操作，可以加锁来保证线程安全：

Java中加锁的两种方式：

• synchronized关键字：申请对给定的Java对象，对象头加锁；
• Lock：是一个锁的接口，它的实现类提供了锁这样的对象，可以调用方法来加锁/释放锁。

对共享变量的写操作，不依赖任何共享变量，也可以使用volatile关键字来保证线程安全。

（2）对共享变量的读操作，使用volatile关键字就可以保证线程安全

volatile关键字：修饰变量，变量的读操作，本身就保证了原子性，volatile的作用是保证可见性和有序性，这样就可以保证线程安全。

二、synchronized关键字

synchronized本质上是修饰指定对象的对象头去。使用角度来看，synchronized必须搭配一个具体的对象来使用。

1、使用

（1）修饰普通方法：锁TestDemo对象

//方法一
public class TestDemo {
    public synchronized void methond() {
    }
}
//方法二
public class TestDemo {
    public  void methond() {
        synchronized(this){
        }
    }
}

（2）修饰静态方法：锁TestDemo对象

//方法一
public class TestDemo {
    public synchronized static void method() {
    }
}
//方法二
public class TestDemo {
    public static void method() {
        synchronized(TestDemo.class){
        }
    }
}

2、特性

（1）互斥

synchronized会起到同步互斥的作用，某个线程执行到某个对象的synchronized中时，如果其他线程也执行到同一个对象synchronized时会阻塞等待。

• 进入synchronized修饰的代码块，相当于加锁；
• 退出synchronized代码块，相当于释放锁。

互斥可以满足原子性，

（2）刷新内存

synchronized结束释放锁，会把工作内存中的数据刷新到主存中；其他线程申请锁时，获取的始终是最新的数据。（满足可见性）。

（3）有序性

某个线程执行一段同步代码，不管如何重排序，过程中不可能有其他线程执行的指令，这样多个线程执行同步代码，就满足一定的顺序。

（4）可重入

同一个线程，可以多次申请同一个对象锁（可重入）

三、volatile关键字

修饰某个变量（实例变量，静态变量）

1、保证可见性

代码在写入volatilt修饰的变量时：

• 改变线程工作内存中volatile变量副本的值
• 将改变后的副本的值从工作内存中刷新到主存中

代码在读取volatile修饰的变量时：

• 从主存中读取volatile变量的最新值到工作内存中
• 从工作内存中读取副本值

2、禁止指令重排序

建立内存屏障，保证代码有序性。

3、不保证原子性

synchronized和volatile有着本质区别。synchronized可以保证原子性，volatile保证的是内存的可见性。

只能在共享变量的读操作以及常量赋值操作时使用（这些操作本身就具有原子性）

四、wait和notify（线程间的通信）

线程通信：线程间通信，就是一个线程以通知的方式，唤醒某些等待的线程（或者让当前线程等待），这样就可以让线程通过通信的方式具有一定的顺序性。

1、wait()方法

wait做的事情：

• 使当前执行代码的线程进入等待状态（把线程放到等待队列中）
• 释放当前的锁
• 满足一定条件时，重新尝试获取这个锁

wait结束等待的条件：

• 其他线程调用该对象的notify方法
• wait等待时间超时（wait提供了一个带一个参数的方法，可以指定等待时间）
• 其他线程调用该等待线程的interrupted方法，导致wait抛出InterruptedException异常

wait要搭配synchronized来使用。脱离synchronized使用wait会直接抛异常。

如下：

Object object = new Object();
    synchronized (object) {
        object.wait();
    }
//这种情况下线程会一直等待下去，这个时候需要使用notify来唤醒

2、notify()和notifyAll()方法

notify方法只是唤醒某一个等待的线程，使用notifyAll方法可以一次性唤醒所有的等待线程。

• notify()也是在同步方法中调用，用来通知其他等待的线程，对其发出通知notify，并使它们重新获取该对象的对象锁；
• 如果有多个线程在等待，则有线程调度器随机挑选出一个处于等待状态的线程；
• notify()方法执行后，当前线程不会立马释放该对象锁，要等到当前线程将程序执行完，退出同步代码块后才会释放对象锁。

【注】

虽然notifyAll()同时唤醒所有处于等待状态的线程，但是这些线程需要竞争锁。所以并不是同时执行，仍然是有先后顺序的执行。

3、wait和sleep的对比

一个是用于线程之间的通信，一个是让线程阻塞一段时间。

• wait需要搭配synchrionzed使用，sleep不用
• wait是Object的方法，sleep是Thread的静态方法

五、线程和进程的比较

1、线程的优点

1. 创建线程的代价比创建进程小得多
2. 与进程切换相比，线程切换需要操作系统做的事少得多
3. 线程占用的资源比进程少
4. 能充分利用多个处理器，提高效率
5. 在等待I/O操作结束的同时，程序可执行其他的计算任务
6. I/O密集型操作，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作
7. 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现

2、线程和进程的区别

• 进程是进行资源分配的最小单位，线程是程序执行的最小单位
• 进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如寄存器和栈
• 同一个进程的各线程之间共享内存和文件资源，可以不通过内核进行直接通信
• 线程的创建、切换、销毁效率更高

到此这篇关于Java深入探索线程安全和线程通信的特性的文章就介绍到这了,更多相关Java线程安全内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！