2022-08-03 第五小组顾祥全学习笔记 day27-JavaSE-多线程-线程安全

激进的韭菜

已于 2022-08-04 23:14:47 修改

阅读量170

点赞数

分类专栏： JavaSE学习笔记文章标签：学习 java 后端开发语言

于 2022-08-04 12:58:22 首次发布

本文链接：https://blog.csdn.net/weixin_56090951/article/details/126157440

版权

JavaSE学习笔记专栏收录该内容

26 篇文章 1 订阅

订阅专栏

线程安全

线程这部分太难了,难以理解,我已经摆烂了,等学完框架后再回过头来总结把

学习内容

线程安全

变量的线程安全问题

局部变量 ——> 无线程安全问题
实例变量 ——> 存放再堆中，存在线程安全问题
静态变量 ——> 存放再方法区中，存在线程安全问题

局部变量和常量不存在线程安全问题

如何保证线程安全？

使用synchronized关键字(自动锁)

1.修饰实例方法，作用于当前实例(this)加锁，进入同步代码前要获得当前实例的锁(对象锁)

语法格式：[修饰符列表] synchronized 返回值类型方法名(参数列表)

2.修饰静态方法，作用于当前类对象(Class对象)加锁，进入同步代码块前要获得的当前类对象的锁(类锁)

语法格式：[修饰符列表] static synchronized 返回值类型方法名(参数列表)

3.同步代码块

语法格式：synchronized (需要同步的线程之间的共享对象) {需要线程同步的代码}

对象锁：对象每个对象都有且仅有一把对象锁，100个对象有100把对象锁
类锁：每个类都有且仅有一把类锁，创建100个该类的对象也只有1把类锁

用代码理解synchronized

题目
假设1个老师，5个学生，我们来模拟一个老师给学习好的三名学生同时发10份笔记本，每次只发放一份笔记本，每个学生相当于一个线程(只给3个线程分配，剩下两个线程不分配)

通过题目看一看出：同学1、同学2、同学3这三个线程共享一个teacher对象，并且这三个线程在分书的过程要求同步，而同学4、同学5这两个线程并不共享teacher对象。

我们可以让Teacher实现Runable接口，在run方法中给分书代码加上synchronize语句块，同时将这个Teacher的实例交给同学1、同学2、同学3这三个线程(Thread)来代理(静态代理)，如下图所示
在这里插入图片描述
具体代码如下

package com.jsoft.homework;

/**
* @author guxiangquan
* @date 2022/8/2
*/

public class Test4 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        new Thread(teacher,"同学1").start();  // 同学1
        new Thread(teacher,"同学2").start();  // 同学2
        new Thread(teacher,"同学3").start();  // 同学3
        new Thread(new Student(),"同学4").start();    // 同学4
        new Thread(new Student(),"同学5").start();    // 同学5

    }
}
class Student implements  Runnable {
    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ ": 我是孤儿，老师不给我发笔记本,555");
        }
    }
}

class Teacher implements Runnable {
    private volatile int noteCount = 10;

    @Override
    public void run() {
            boolean flag = true;
            while (flag) {
                flag = distribute();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
    public  boolean distribute() {
         synchronized (this) {
             if(noteCount <= 0) {
                 return false;
             }
             System.out.println(Thread.currentThread().getName() + "收到一份笔记本，还剩下：" + (--noteCount) + "本");
             return true;
         }

    }
}

在这里插入图片描述

编写代码时遇到的问题

使用synchronized语句块时，使用this作为共享对象，这个this是指Thread实例还是Teacher实例？

想要知道this具体指向的是谁，就需要知道究竟是谁调用的run()方法。我们都知道使用start()方法会调用run()方法，由于是Thread实例调用的start()，那让我们来看一下Thread类中的源码(Java8)

strat()中调用了start0()

在这里可以看出是target调用了run()，而trager就是我们创建Thread时候传入的Teacher，
结论：run()是由Teacher(Runnable)这个被代理类实例所调用的，而this就是传入的这个Teacher实例

上面代码中synchronized语句块中给this加锁示例图
在这里插入图片描述

使用原子类

什么是原子类?

Java中的原子类是java.util.concurrent.atomic包下的对象，他们之所以有原子性的共性，都来源于CAS，可见CAS的重要性。对于原子类变量的操作是不会存在并发性问题的，不需要使用同步手段进行并发控制。它底层自身的实现即可保证变量的可见性以及操作的原子性，一般我们可以使用AtomicInteger，AtomicLong等实现计数器等功能，利用AtomicBoolean实现标志位等功能。

点我查看

AtomicInteger类与AtomicLong类

对于AtomicInteger、ActomicLong这两个类由于他们的方法相似，所以只需要了解AtomicInteger类的使用，便能了解ActomicLong类的使用

包路径: java.util.concurrent.atomic.AtomicInteger/AtomicLong
继承关系:AtomicInteger/AtomicLong类 —> Number类 —> Object类

构造方法
在这里插入图片描述

实例方法

方法	功能
void set()	设置当前值
int get()	获取当前值
int intValue() int longValue() int floatValue() int doubleValue	实现Number抽象类的抽象方法返回当前值的不同类型
int getAndIncrement()	先返回当前值在自增，类似于 i++
int getAndDecrement()	先返回当前值在自减，类似于 i- -
int incrementAndGet()	先自增再返回当前值，类似于 ++i
int decrementAndGet()	先自减再返回当前值，类似于 - -i
int addAndGet(int)	先让当前值加上参数值，再返回当前值
int getAndAdd(int)	先返回当前值，再让当前值加上参数值
boolean compareAndSet(int expect, int update)	判断当前值是否于expect相等，如果相等将当前值修改为update，并且返回true, 如果不相等，并不修改当前值并且返回false
weakCompareAndSet(int expect, int update)	与compareAndSet()无异

其中所有含算数运算的方法都是原子操作

AtomicBoolean类

包路径: java.util.concurrent.actomic.AtomicBoolean
继承关系:AtomicBollean类 —> Object类
构造方法
在这里插入图片描述
实例方法

AtomicIntegerArray类与AtomicLongArray类

待补充…

使用Lock(手动锁)

Lock接口的实现类ReentrantLock
ReentrantLock，可重入锁
实现了Lock接口

synchronized和ReentrantLock区别

synchronized发生异常时，会自动释放线程占用的锁不会发生死锁；Lock发生异常，若没有主动释放，极有可能占用资源不放手，而需要再finally中手动释放锁
Lock可以让等待锁的线程中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
Lock可以提高多个线程进行读操作的效率

Lock以下功能时synchronized不具备的

ReentrantReadWriteLock:
对于一个应用而言，一般情况下读错做远远多于写操作，如果仅仅是读的操作没有写的操作，数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能由线程再写，写是独占的，当有线程再执行写的操作，其他线程既不能读，也不能写。
再某些场景下能极大提高效率

Lock锁的原理cas和aqs
synchronized是由c语言实现的，只能作为关键字来使用
java提供了一些并发的编程的包，底层原理cas和aqs