【线程】——线程安全问题

最新推荐文章于 2024-06-20 18:00:24 发布

你这家伙

最新推荐文章于 2024-06-20 18:00:24 发布

阅读量169

点赞数 4

文章标签：多线程 java

本文链接：https://blog.csdn.net/wkh18891843165/article/details/114952303

版权

线程状态：
NEW(就绪状态，此时还没有调用start方法)；
RUNABLE(运行状态)；
TIMED_WAITING(调用sleep，有时间的等待)；
WAITING(调用wait)；
BLOCKED(调用加锁)；
TIMENATED销毁状态(运行完了)；

什么是线程安全？

多线程执行一组代码出现了逻辑错误，就表示它为非线程安全。
多个线程执行一组代码时，不会出现逻辑错误就是线程安全。
来看一个示例：
示例步骤：
第一步：有一个main主线程
第二步：创建了第二个线程t1，然后让count++一万次
第三步：创建了第三个线程t2，然后让count++一万次
第四步：输出结果；
按道理说；当t1和t2执行完成之后输出的结果应该是20000

public  class ThreadDemo9 {

    public static  class Counter{
        private static int count = 0;
        public static void increment(){
            count++;
        }
    }
    private static long size = 1_0000;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < size; i++) {
                Counter.increment();
            }
        });
        t1.start();
        Thread  t2= new Thread(()->{
            for (int i = 0; i < size; i++) {
                Counter.increment();
            }
        });
        t2.start();
        //这里一定要加上join，线程t1和线程t2执行完毕
        t1.join();
        t2.join();
        System.out.println(Counter.count);
    }
}

看看运行结果：
在这里插入图片描述
那么结果为什么不是20000呢？——这就引出了线程的并发问题，也就是线程的不安全问题

在这里插入图片描述
分析问题：两个线程的执行逻辑

导致线程非安全的问题因素：
线程因为同时读取和同时修改，导致修改的值被覆盖就会出现非线程安全的问题

a)修改线程是非原子的
b）多个线程修改同一个变量（这个是不安全的）
b.1多个线程读取同一变量（这个是线程安全的）
b.2一个线程读取一个变量（这个也是安全的）
c）因为多线程是抢占式执行的（万恶之源）
d）内存的可见性（是因为一个线程在修改，另一个线程在读取，因为读取的频率比较高，因此读取代码被CPU优化存储到寄存器了，使用当另一个线程修改之后，对它是不可见的，因此就造成了内存可见性的问题，那么如何解决内存可见性问题，使用volatile关键字，这个关键字解决一个线程修改，多个线程读取的问题）
e）编译器优化（这种优化再单线程下是没有问题的，但是再多线程下就会出现问题）

就上面五种情况来说如何解决线程不安全
1.抢占式执行（不可控）
2.使用锁来解决
3.一个线程修改一个变量的时候也是线程（也就是再每个线程里面定义一个变量，然后分别进行++，最后求两个变量的和）
4.那就是jion操作，再线程1后面加上join，先让线程1执行完，再去执行线程2，但是这违背了线程并发的，所以不可取
注意：多线程抢占式执行时内核操作的，是不可控的，所以这个解决抢占式是不可取的。

如何解决线程不安全问题

使用锁来解决：Java中的锁有两种：
（1）.synchronized锁（同步锁）——JVM的一个自动锁，不需要加锁和解锁操作
（2.）lock（手动锁）

方法一：使用synchronized进行加锁操作
再上面那个代码直接加上synchronized 在这里插入图片描述
然后看看执行效果，此时已经得到我们想要的结果了

在这里插入图片描述
那么为什么这个加上锁之后就成功了呢？他的执行流程是什么样的呢？那么请看下面这张图解

在这里插入图片描述
虽然多线程是并发进行的，线程1和线程2会并发的进行加锁，但是线程1先加的锁（原因是并发执行微观上还是一个个执行的），当线程2去加锁的时候发现已经有了锁，此时会有一个竞争锁，但是线程2竞争失败，那么线程2就只能等线程1释放锁之后再去执行（比如：去ATM自动取款机存取钱，当第一个人进去的时候，这时候门就会自动锁上，那么后面的人只能等待排队）。

在这里插入图片描述

synchronized的常见用法

修饰静态方法
修饰普通方法
修饰代码块

问题一：为什么synchronized能够实现加锁的操作呢？
是因为底部是JVM(Java虚拟机)实现了自动加锁和解锁的操作

问题二：锁为什么能够保证线程的安全？
是因为锁的基本特性：互斥性，也就是同一时间，只有一个线程能够获得锁

synchronized，JVM实现的加锁和解锁过程

synchronized锁的注意事项

1.使用synchronized一定要加同一把锁。
2.synchronized在JDK1.6性能是非常的底，因此在这个版本之前基本上使用的是Lock锁
2.1 synchronized在JDK1.6做了一个优化：刚开始无锁的时候他的对象头里面有一个隐藏属性，此属性是用来记录获取他的（锁）线程的线程ID，他会将这个属性的值设置为此线程的ID，再有其他线程过来之后，会判断线程ID相不相等，如果相等就表示是同一个线程可以继续执行下面的操作，如果线程ID不相等，表示此锁已经被使用，这个线程只能等待。等待并不是静止不动，而是通过自旋（自己循环）的方式循环判断锁是否已经被使用完，如果自选里一段时间没有获得锁，此锁就会将锁的等级从轻量级升级为重量级锁。这就是锁升级的过程。

方法二
首先看代码

public class ThreadDemo10 {
    static class Counter {
        private static int count = 0;
        //首先声明一把锁,但是需要将这把锁变成全局锁，只有在JVM启动的时候加载一次
       static Lock lock = new ReentrantLock();

        public static void increment() {
            //第一步：执行加锁操作
            lock.lock();
            //为了保证++操作完成之后会释放锁，所以把它放在finnaly里面
            try {
                //第二步执行代码逻辑++操作
                count++;
            }finally {
                //第三步：释放锁
                lock.unlock();
            }

        }
    }
    private static final int size = 1_0000;
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(()->{
            for (int i = 0; i < size; i++) {
                Counter.increment();
            }
        });
        thread1.start();
        Thread thread2 = new Thread(()->{
            for (int i = 0; i < size; i++) {
                Counter.increment();
            }
        });
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(Counter.count);
    }

}

他的逻辑实现步骤和synchronized的雷同，看上图详解
注意几个细节部分：
在这里插入图片描述

synchronized锁和lock锁的区别

synchronized它可以修饰普通方法，静态方法，代码块，而lock只能修饰代码块
lock锁的灵活性更高一些，lock锁粒度更小（synchronized修饰的是整个方法，而使用lock锁的时候只需要将原子操作（也就是++掺操作放在里面））
lock可以用来创建公平锁，而synchronized默认的是非公平锁
lock创建非公平锁的方式：加上false，如果lock想创建公平锁，只需将false改成true

那么什么是公平锁，什么是非公平锁呢？
公平锁：指CPU安装线程访问的先后顺序依次执行
非公平锁：指CPU调度是采用抢占式的方式进行调用的

Java之所以所有的锁默认是非公平锁是因为：非公平锁的效率更高,利用率会更高（肯定很多人一开始认为公平是最好的，那么线程不一样：
例如：有一个图书馆，里面的座位需要预约，然后当天的座位被预约满了，但是其中有一部分很长时间没有来，如果是公平的话，那么座位肯定会被浪费掉，那么再来人的话，就没有位置了，即便那个作为是空着的，但是如果是不公平的话，那么这个位置空的时候，再来人的时候就可以让这个人先使用，那么就不会造成资源的浪费
）

锁存在的意义就是多线程编程
锁保证了多线程的执行逻辑正确（线程安全），但同时牺牲了性能

你这家伙

关注

4
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
【线程】——线程安全问题

什么是线程安全？多线程执行一组代码出现了逻辑错误，就表示它为非线程安全。多个线程执行一组代码时，不会出现逻辑错误就是线程安全。来看一个示例：示例步骤：第一步：有一个main主线程第二步：创建了第二个线程t1，然后让count++一万次第三步：创建了第三个线程t2，然后让count++一万次第四步：输出结果；按道理说；当t1和t2执行完成之后输出的结果应该是20000public class ThreadDemo9 { public static class Counte
复制链接

扫一扫