java多线程如何保证线程安全,Java多线程安全
00-1010 1.线程安全概述1.1什么是线程安全问题1.2有线程安全问题的程序2。线程锁死和线程不安全的原因2.1案例分析2.2线程锁死2.2.1什么是锁死2.2如何锁死2.2.3案例再分析2.3线程不安全的原因3。螺纹安全标准等级4。4提供的线程等待方法。对象类别前言：
本文介绍了Java多线程中的线程安全问题。这里的安全问题不是指黑客攻击导致的安全问题，线程安全问题是指多线程抢先执行导致的bug问题。
目录
00-1010首先我们要明白，操作系统中线程的调度是抢占式执行，或者说是随机的，这就造成了线程的执行顺序是不确定的。有些代码执行顺序不一样，不会影响程序的运行结果，但是有些代码执行顺序改变了，重写后的运行结果会受到影响，会造成程序的bug。多线程并发时会导致bug的代码称为线程不安全代码，也就是线程安全问题。
接下来介绍一个线程安全问题的典型例子，整数自增量问题。
00-1010有一天，老师布置了这样一个问题：用两个线程增加变量计数10万次，每个线程承担5万个自增任务，变量计数的初始值为0。这个问题很简单，我们可以口头算算最后的结果。答案是10万元。小明做事非常迅速，很快就写出了下面的代码：
类计数器{ private int countpublic void increase(){ this . count；} public int get count(){ return this . count；} }公共类main 11 { private static final int CNT=50000；私有静态最终计数器Counter=new Counter()；public static void main(String[]args)抛出interrupted exception { Thread Thread 1=new Thread(()-{ for(int I=0；我CNTI){ counter . increase()；} });Thread thread2=新线程(()-{ for(int j=0；j CNTj){ counter . increase()；} });thread 1 . start()；thread 2 . start()；thread 1 . join()；thread 2 . join()；system . out . println(counter . get count())；}}按理说结果应该是10万。让我们来看看运行结果：
跑的结果不到10万。你可以试着运行这个程序，你会发现每次运行的结果都不一样，但大多数情况下，结果会比预期值小。我们来分析一下为什么会这样。
1.线程安全概述
00-1010上，我们用多线程运行了一个程序，把一个变量值为0的变量增加了10万倍，但是最后的实际结果比我们预期的结果要小。原因是线程调度的顺序是随机的，导致线程间自增指令集的交叉，导致运行时出现两个自增但只有一个自增的情况，所以得到的结果会太小。
我们知道一次自增操作可以包含以下几条指令：
将内存中变量的值载入寄存器。您可能希望将此操作记录为LOAD。如果在寄存器中执行自增操作，也可以将此操作记录为add。将寄存器的值保存到内存中，这个操作就像保存一样容易记住。我们来画一条时间轴，来总结一下常见的几种情况：
情况1：跨线手指
令集，无交叉，运行结果与预期相同，图中寄存器A表示线程1所用的寄存器，寄存器B表示线程2所用的寄存器，后续情况同理。
情况2：线程间指令集存在交叉，运行结果低于预期结果。
情况3：线程间指令集完全交叉，实际结果低于预期。
根据上面我们所列举的情况，发现线程运行时没有交叉指令的时候运行结果是正常的，但是一旦有了交叉会导致自增操作的结果会少1，综上可以得到一个结论，那就是由于自增操作不是原子性的，多个线程并发执行时很可能会导致执行的指令交叉，导致线程安全问题。
那如何解决上述线程不安全的问题呢？当然有，那就是对对象加锁。
2.2线程加锁
2.2.1什么是加锁
为了解决由于抢占式执行所导致的线程安全问题，我们可以对操作的对象进行加锁，当一个线程拿到该对象的锁后，会将该对象锁起来，其他线程如果需要执行该对象的任务时，需要等待该线程运行完该对象的任务后才能执行。
举个例子，假设要你去银行的ATM机存钱或者取款，每台ATM机一般都在一间单独的小房子里面，这个小房子有一扇门一把锁，你进去使用ATM机时，门会自动的锁上，这个时候如果有人要来取款，那它得等你使用完并出来它才能进去使用ATM，那么这里的你相当于线程，ATM相当于一个对象，小房子相当于一把锁，其他的人相当于其他的线程。
在java中最常用的加锁操作就是使用synchronized关键字进行加锁。
2.2.2如何加锁
synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。 线程进入 synchronized 修饰的代码块, 相当于加锁，退出 synchronized 修饰的代码块, 相当于解锁。
java中的加锁操作可以使用synchronized关键字来实现，它的常见使用方式如下：
方式1：使用synchronized关键字修饰普通方法，这样会使方法所在的对象加上一把锁。 例如，就以上面自增的程序为例，尝试使用synchronized关键字进行加锁，如下我对increase方法进行了加锁，实际上是对某个对象加锁，此锁的对象就是this，本质上加锁操作就是修改this对象头的标记位。
class Counter { private int count; synchronized public void increase() { ++this.count; } public int getCount() { return this.count; }}多线程自增的main方法如下，后面会以相同的栗子介绍synchronized的其他用法，后面就不在列出这段代码了。
public class Main11 { private static final int CNT = 50000; private static final Counter counter = new Counter(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { for (int i = 0; i < CNT; i++) { counter.increase(); } }); Thread thread2 = new Thread(() -> { for (int j = 0; j < CNT; j++) { counter.increase(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(counter.getCount()); }}看看运行结果：
方式
2：使用synchronized关键字对代码段进行加锁，但是需要显式指定加锁的对象。 例如：
class Counter { private int count; public void increase() { synchronized (this){ ++this.count; } } public int getCount() { return this.count; }}运行结果：
方式3：使用synchronized关键字修饰静态方法，相当于对当前类的类对象进行加锁。
class Counter { private static int count; synchronized public static void increase() { ++count; } public int getCount() { return this.count; }}运行结果：
常见的用法差不多就是这些，对于线程加锁（线程拿锁），如果两个线程同时拿一个对象的锁，就会产生锁竞争，两个线程同时拿两个不同对象的锁不会产生锁竞争。 对于synchronized这个关键字，它的英文意思是同步，但是同步在计算机中是存在多种意思的，比如在多线程中，这里同步的意思是互斥；而在IO或网络编程中同步指的是异步，与多线程没有半点的关系。
synchronized 的工作过程:
获得互斥锁lock从主内存拷贝变量的最新副本到工作的内存执行代码将更改后的共享变量的值刷新到主内存释放互斥锁unlocksynchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题，即死锁问题，关于死锁后续文章再做介绍。
综上，synchronized关键字加锁有如下性质：互斥性，刷新内存性，可重入性。synchronized关键字也相当于一把监视器锁monitor lock，如果不加锁，直接使用wait方法（一种线程等待的方法，后面细说），会抛出非法监视器异常，引发这个异常的原因就是没有加锁。
2.2.3再析案例
对自增那个代码上锁后，我们再来分析一下为什么加上了所就线程安全了，先列代码：
class Counter { private int count; synchronized public void increase() { ++this.count; } public int getCount() { return this.count; }}public class Main11 { private static final int CNT = 50000; private static final Counter counter = new Counter(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { for (int i = 0; i < CNT; i++) { counter.increase(); } }); Thread thread2 = new Thread(() -> { for (int j = 0; j < CNT; j++) { counter.increase(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println(counter.getCount()); }}多线程并发执行时，上一次就分析过没有指令集交叉就不会出现问题，因此这里我们只讨论指令交叉后，加锁操作是如何保证线程安全的，不妨记加锁为lock，解锁为unlock，两个线程运行过程如下： 线程1首先拿到目标对象的锁，对对象进行加锁，处于lock状态，当线程2来执行自增操作时会发生阻塞，直到线程1的自增操作完毕，处于unlock状态，线程2才会就绪取执行线程2的自增操作。
加锁后线程就是串行执行，与单线程其实没有很大的区别，那多线程是不是没有用了呢？但是对方法加锁后，线程运行该方法才会加锁，运行完该方法就会自动解锁，况且大部分操作并发执行是不会造成线程安全的，只有少部分的修改操作才会有可能导致线程安全问题，因此整体上多线程运行效率还是比单线程高得多。
2.3线程不安全的原因
首先，线程不安全根源是线程间的调度充满随机性，导致原有的逻辑被改变，造成线程不安全，这个问题无法解决，无可奈何。多个线程针对同一资源进行写（修改）操作，并且针对资源的修改操作不是原子性的，可能会导致线程不安全问题，类似于数据库的事务。
由于编译器的优化，内存可见性无法保证，就是当线程频繁地对同一个变量进行读操作时，会直接从寄存器上读值，不会从内存上读值，这样内存的值修改时，线程就感知不到该变量已经修改，会导致线程安全问题（这是编译器优化的结果，现代的编译器都有类似的优化不止于Java），因为相比于寄存器，从内容中读取数据的效率要小的多，所以编译器会尽可能地在逻辑不变的情况下对代码进行优化，单线程情况下是不会翻车的，但是多线程就不一定了，比如下面一段代码：
import java.util.Scanner;public class Main12 { private static int isQuit; public static void main(String[] args) { Thread thread = new Thread(() -> { while (isQuit == 0) { } System.out.println("线程thread执行完毕!"); }); thread.start(); Scanner sc = new Scanner(System.in); System.out.println("请输入isQuit的值，不为0线程thread停止执行!"); isQuit = sc.nextInt(); System.out.println("main线程执行完毕!"); }}运行结果：
我们从运行结果可以知道，输入isQuit后，线程thread没有停止，这就是编译器优化导致线程感知不到内存可见性，从而导致线程不安全。 我们可以使用volatile关键字保证内存可见性。 我们可以使用volatile关键字修饰isQuit来保证内存可见性。
import java.util.Scanner;public class Main12 { volatile private static int isQuit; public static void main(String[] args) { Thread thread = new Thread(() -> { while (isQuit == 0) { } System.out.println("线程thread执行完毕!"); }); thread.start(); Scanner sc = new Scanner(System.in); System.out.println("请输入isQuit的值，不为0线程thread停止执行!"); isQuit = sc.nextInt(); System.out.println("main线程执行完毕!"); }}运行结果：
synchronized与volatile关键字的区别：synchronized关键字能保证原子性，但是是否能够保证内存可见性要看情况（上面这个栗子是不行的），而volatile关键字只能保证内存可见性不能保证原子性。 保证内存可见性就是禁止编译器做出如上的优化而已。
import java.util.Scanner;public class Main12 { private static int isQuit; //锁对象 private static final Object lock = new Object(); public static void main(String[] args) { Thread thread = new Thread(() -> { synchronized (lock) { while (isQuit == 0) { } System.out.println("线程thread执行完毕!"); } }); thread.start(); Scanner sc = new Scanner(System.in); System.out.println("请输入isQuit的值，不为0线程thread停止执行!"); isQuit = sc.nextInt(); System.out.println("main线程执行完毕!"); }}运行结果：
编译器优化除了导致内存可见性感知不到的问题，还有指令重排序也会导致线程安全问题，指令重排序也是编译器优化之一，就是编译器会智能地（保证原有逻辑不变的情况下）调整代码执行顺序，从而提高程序运行的效率，单线程没问题，但是多线程可能会翻车，这个原因了解即可。
3.线程安全的标准类
Java 标准库中很多都是线程不安全的。这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施。例如，ArrayList，LinkedList，HashMap，TreeMap，HashSet，TreeSet，StringBuilder。 但是还有一些是线程安全的，使用了一些锁机制来控制，例如，Vector (不推荐使用)，HashTable (不推荐使用)，ConcurrentHashMap (推荐)，StringBuffer。 还有的虽然没有加锁, 但是不涉及 "修改", 仍然是线程安全的，例如String。
在线程安全问题中可能你还会遇到JMM模型，在这里补充一下，JMM其实就是把操作系统中的寄存器，缓存和内存重新封装了一下，其中在JMM中寄存器和缓存称为工作内存，内存称为主内存。 其中缓存分为一级缓存L1，二级缓存L2和三级缓存L3，从L1到L3空间越来越大，最大也比内存空间小，最小也比寄存器空间大，访问速度越来越慢，最慢也比内存的访问速度快，最快也没有寄存器访问快。
4.Object类提供的线程等待方法
除了Thread类中的能够实现线程等待的方法，如join,sleep，在Object类中也提供了相关线程等待的方法。
序号方法说明1public final void wait() throws InterruptedException释放锁并使线程进入WAITING状态2public final native void wait(long timeout) throws InterruptedException;相比于方法1，多了一个最长等待时间3public final void wait(long timeout, int nanos) throws InterruptedException相比于方法2，等待的最长时间精度更大4public final native void notify();唤醒一个WAITING状态的线程，并加锁，搭配wait方法使用5public final native void notifyAll();唤醒所有处于WAITING状态的线程，并加锁（很可能产生锁竞争），搭配wait方法使用上面介绍synchronized关键字的时候，如果不对线程加锁会产生非法监视异常，我们来验证一下：
public class TestDemo12 { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(() -> { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("执行完毕！"); }); thread.start(); System.out.println("wait前"); thread.wait(); System.out.println("wait后"); }}看看运行结果：
果然抛出了一个IllegalMonitorStateException，因为wait方法的执行步骤为：先释放锁，再使线程等待，你现在都没有加锁，那如何释放锁呢？所以会抛出这个异常，但是执行notify是无害的。
wait方法常常搭配notify方法搭配一起使用，前者能够释放锁，使线程等待，后者能获取锁，使线程继续执行，这套组合拳的流程图如下：
现在有两个任务由两个线程执行，假设线程2比线程1先执行，请写出一个多线程程序使任务1在任务2前面完成，其中线程1执行任务1，线程2执行任务2。 这个需求可以使用wait/notify来实现。
class Task{ public void task(int i) { System.out.println("任务" + i + "完成！"); }}public class WiteNotify { //锁对象 private static final Object lock = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(() -> { synchronized (lock) { Task task1 = new Task(); task1.task(1); //通知线程2线程1的任务完成 System.out.println("notify前"); lock.notify(); System.out.println("notify后"); } }); Thread thread2 = new Thread(() -> { synchronized (lock) { Task task2 = new Task(); //等待线程1的任务1执行完毕 System.out.println("wait前"); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } task2.task(2); System.out.println("wait后"); } }); thread2.start(); Thread.sleep(10); thread1.start(); }}运行结果：
到此这篇关于Java多线程之线程安全问题详情的文章就介绍到这了,更多相关Java线程安全内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。