并发安全基础(4)

1.并发三要素

  • 原子性:
    java中指,一个或多个操作,要么全部执行成功,要么全部执行失败。
  • 有序性:
    程序执行的顺序要按照代码的先后顺序。
  • 可见性:
    当多个线程访问同一个变量时,如果其中一个线程对变量做了修改,其他线程要立即获取到最新的值。

2.线程的五大状态

  • 创建:
    用new操作创建一个线程的时候。
  • 就绪:
    调用start方法,处于就绪状态的线程,并不一定马上调用run方法执行,还要等待cpu的调度。
  • 运行:
    cpu开始调度线程,并开始执行run方法。
  • 阻塞:
    线程的执行过程中由于一些原因进入阻塞状态,比如,执行sleep方法,或者尝试获取一个锁等。
  • 死亡:
    run方法执行完,或者遇到异常。

3.悲观锁和乐观锁

  • 悲观锁:
    每次操作都会加锁,造成线程阻塞。
  • 乐观锁:
    每次操作都不加锁,假设没有冲突去完成某些操作,如果因为冲突失败就重试,直到成功为止,不会造成线程阻塞。

4.线程之间协作

4.1wait、notify、notifyAll(这是一组Object类方法,必须在同步范围内调用)

  • wait:
    wait有三种方式唤醒,notify、notyfyAll或者wait(longtimeout),其中longtimeout如果没有notify或者notifyAll也会在指定时间内唤醒。
  • notify
    只能唤醒一个处于wait()的线程。
  • notifyAll
    唤醒全部处于wait()的线程。

4.2sleep、yield、join(这是一组Thread类的方法)

  • sleep
    让当前线程暂停指定之间,只是让出cpu的使用权,并不释放锁
  • yield
    暂停当前线程的执行,让出当前cpu的使用权,不能指定时间,会使当前线程从运行状态变为就绪状态,在生产中很少使用。
  • join
    等待调用jion方法后,才执行后面的代码,此方法一定要在start后用。
    场景:当主线程需要等待子线程执行结束后才执行后面的操作

wait和join对比:
1.wait是 Object 类中的方法,join是 Thread 类中的方法。
2.sleep方法调用后不会释放做,线程仍然可以同步控制,不会让出系统资源,而wait进入线程等待池中等待,让出系统资源。
3.调用wait方法的线程不会自动唤醒,需要线程调用notify或者notifyAll,才会进入就绪队列中等待系统分配资源;而sleep方法会自动唤醒,如果时间不到,想要唤醒,可以使用interrupt强制打断。
使用范围:
sleep可以在任何地方使用,而wait、notify、notifyAll只能在同步方法或同步块中使用。
sleep必须捕获异常,而wait、notify、notifyAll不需要。

5.volatile

5.1 是什么:
被volatile声明的变量在内存模型中可被全局可见,volatile是轻量级的sychronized,不会引起线程上下文切换和调度,开销更小。

5.2 原理:

  • 使用volatile修饰的变量,在汇编阶段,会多出一条lock前缀的指令。
  • 会强制将对内存的修改操作立即写入主存。
  • 如果是写操作,会导致其他cpu里缓存了该内存地址大数据无效。

5.3 作用:

  • 内存可见
  • 多线程操作的时候,一个线程修改了一个变量的值,其他线程能够立即看到修改后的值。
  • 全局可见,但是,不能保证原子性。

volatile不是并发安全举例:
两个线程A、B同时修改一个int i=5,A执行i++,B同时执行i++,写回主存后都是6,但是,其实 i 执行了两次++

6.sychronized

确保线程互斥的访问同步

6.1定义:
sychronized是jvm实现的一种锁,锁的获取和释放分别是monitorenter和monitorenxit指令,在实现上分为了:偏向锁、轻量级锁和重量级锁,偏向锁在jdk1.6是默认开启,轻量锁在多线程竞争情况下会膨胀成重量级锁,有关锁的数据都保存在对象头中。

6.2作用:

  • 修饰普通方法(同步对象是实例对象)
  • 修饰静态方法(同步对象是类本身)
  • 修饰代码块 (可以自己设置同步对象)

6.3缺点:
会让没有得到锁的资源进入Block状态,争夺资源后又转为Running状态,这个过程涉及到操作系统用户模式和内核模式的切换,代价很高,java1.6后对sychronized做了优化,增加了偏向锁到轻量锁到重量锁的过程,但是最终转变为重量锁之后,性能仍然很低。

7.CAS

7.1描述:
AtomicBoolean、AtomicInteger、AtomicLong以及lock相关的类等底层都是CAS 实现的,性能比sychronized更高。

7.2是什么:
全称,compare and set(swap),即比较和替换,操作包含三个操作数,内存位置(v),预期原值(A)和新值(B),如果内存位置和预期原值相匹配,处理器将自动将该位置的值更新为新值,否则,处理器不做任何处理。

7.3为什么会出现CAS:

  • 如果只用sychronized保证同步会造成如下问题:
    sychronized是一种悲观锁,使用上会造成一定性能问题。在多线程竞争下,加锁、释放锁会导致较多的上下文切换和调度延时,一个线程持有锁后,会导致其他所有需要此锁的线程挂起。

7.4实现原理:
java不能直接访问操作系统底层,通过native(jni)来访问。CAS底层通过unsafe类实现原子操作。

7.5存在的问题:

ABA问题:
比如,int N = 1,此时有三个线程想去改变N:
线程A:希望给N赋值为2
线程B:希望给N赋值为2
线程C:希望给N赋值为1
此时,线程A和B同时获取N为1,A率先获得系统资源,将N=2,B由于某种原因被阻塞,C在A执行完毕后获得N当前值为2,然后把1赋给了N。
最后B获得了系统资源,又恢复了运行状态,此时,在阻塞前,B取到的值为1,执行compare后发现,当前N的值还是1,然后成功将N赋值为2。
在这个过程中,B阻塞时获取到N的旧值是1,虽然和当前值(被C修改后)相等,但实际上N经历过了一次1->2->1的改变。

这就是典型的ABA的问题。

7.6如何解决:
给变量增加一个版本号即可,在比较的时候不仅要比较当前变量值,还要比较当前变量的版本号,java中,AtomicStampedReference就解决了这个问题。
在并发高的环境下,如果许多线程反复尝试更新一个变量,却一直更新不成功,循环往复,会给cpu带来很大压力,CAS只能保证一个共享变量的原子操作。

8.AQS(AbstraceQueuedSynchronizer)

8.1是什么:
即:抽象的队列同步器,是一种基于状态(state)的链表管理方式,state是由CAS去修改状态,state的修饰关键字是volatile。
AQS定义了一套多线程访问共享资源的同步框架,是java.util.concurent包中的重要基石,许多同步类的实现都基于CAS,比如ReentractLock、CountDownLatch、Semaphoer等。

8.2 ReentractLock(显示锁、互斥锁、可重入锁)

  • ReentractLock实现了java.util.concurrent.lock
  • 性能更佳,当多线程都想访问共享资源时,jvm可以花更少的时间来调度线程,把更多的时间用在执行线程上。
  • ReentrackLock获取方式:
    1.lock(),获取锁后立即返回,如果其他线程持有锁,当前线程一直处于休眠状态,知道获取锁。
    2.tryLock(),如果获取了锁,立即返回true,如果别的线程正持有锁,立即返回false。
    3.tryLock(long timeout,TimeUtil util),如果获取了锁,立即返回true,如果其他线程正在持有锁,会等参数给定的时间,在等待过程中,如果持有立即返回true,如果没有,返回fase。
    4.lockInterruptibly,如果获得锁立即返回,如果没有,当前线程处于休眠状态,直到获得锁,或当前线程被其他线程中断。
//代码段
Lock lock = new ReentractLock();//参数默认false,不公平锁
lock.lock();
try{//Todo
}finally{
  lock.unlock
}

ReentractLock和Synchronized对比: (都是互斥锁)
1.除了实现同步外,添加了类似锁投票、定时锁等候和可中断锁的一些特征。
2.lock必须在finally块中释放锁
3.线程ab都要获取c,a先获取到了c的锁,synchronized会一直等待a的释放,不中断;reentracklock如果a一直不释放,可以使b等了足够时间后,中断等待,去做别的事。
4.Synchronized是jvm层面上的,不但可以通过监控工具监控synchronized的状态,而且如果出现异常,jvm会自动释放锁,但是lock不行,lock是接口,通过代码实现。
5.在竞争不是很激烈的情况下,synchronized的性能要优于ReentrackLock,竞争激烈的情况下Synchronized性能会下降几十倍,但是reentracklock性能则维持常态。
6.Synchronized是非公平锁,ReentrackLock 可以 设置为公平锁:
cpu调度线程会在等待队列里随机选,这样会产生饥饿现象,公平锁可以按照等待的时间先后顺序执行(大体是这样,不一定)

//创建公平锁,入参为true,默认是非公平false
private static ReentrantLock lock=new ReentrantLock(true);
//reentracklock创建内部实现
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

7.内置锁(synchronized)和Lock都是重入锁、互斥锁:
当一个线程得到一个对象后,再次请求该对象锁时是可以得到锁的,自己可以再次获取自己的内部锁,如下:
调用method1()时,已经获得了锁,调用内部method2时,由于本身已经具有锁,所以可以再次获取。

public class SynchronizedTest {
   public void method1() {
       synchronized (SynchronizedTest.class) {
           System.out.println("方法1获得ReentrantTest的锁运行了");
           method2();
       }
   }
   public void method2() {
       synchronized (SynchronizedTest.class) {
           System.out.println("方法1里面调用的方法2重入锁,也正常运行了");
       }
   }
   public static void main(String[] args) {
       new SynchronizedTest().method1();
   }
}
public class ReentrantLockTest {
    private Lock lock = new ReentrantLock();
    public void method1() {
        lock.lock();
        try {
            System.out.println("方法1获得ReentrantLock锁运行了");
            method2();
        } finally {
            lock.unlock();
        }
    }
    public void method2() {
        lock.lock();
        try {
            System.out.println("方法1里面调用的方法2重入ReentrantLock锁,也正常运行了");
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        new ReentrantLockTest().method1();
    }
}

8.lock知道有没有成功获取到锁,syn不可以。
9.lock可以提高多线程进行读操作的效率。

6.Atomic,竞争不激烈的情况下,比syn性能略低,激烈情况下性能优于syn,但是,缺点,一段代码中只能出现一个Atomic,多于1个,则同步无效,不能在多个Atomic之间同步。
7.两个的开销差距是在释放锁时唤醒线程的数量,Synchronized是唤醒锁里池里所有线程+刚好来访问的线程,reetrancklock是当前线程后,进来的第一个线程+刚好来范文的线程。

  • 在用的时候优先考虑Synchronized,如果reentrakclock和Atomic用的不好,可能会带来灾难。
  • 如果线程可以在30-50次之间自旋里拿到锁,Synchronized就不会升级为重量锁,等待线程也不会被挂起,也就减少了挂起和唤醒和上限为切换的开销。

8.3 ReadWriteLock读写锁

  • 读写锁ReadWriteLock是一个接口,ReentractReadWriteLock实现了这个接口
  • 读写锁将一个自由的访问分成两个锁,一个读,一个写。
  • 多线程之间读操作可以并发访问,不需要同步,写操作需要同步,提高了效率,适用于读多写少的场景。
  • 可以通过readLock()获取读锁,writeLock()获取写锁。
  • 可实现功能:释放优先、读线程插队、重入性、降级、升级
    ReadWriteLock接口代码:
publi interface ReadWriteLock(){
  Lock readLock();
  Lock writeLock();
}

ReentrantReadWriteLock(),提供了公平锁和费公平锁两种创建方式:

设计一个缓存,利用读写锁(读数据用读锁,写数据用写锁):

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteCatch {

    private ConcurrentHashMap<String,Object> safeHashMap = new ConcurrentHashMap();
    private ReadWriteLock rw = new ReentrantReadWriteLock();

    public String getKey(String key){

        Object value = null;
        rw.readLock().lock();//获取读锁
        try{
            value = safeHashMap.get(key);

            if(value == null){//缓存中没有该值,从数据库获取,并写入缓存
                rw.readLock().unlock();//释放读锁,获取写锁,查出数据后,写入缓存
                rw.writeLock().lock();
                try{
                    if(value == null){
                        System.out.println("从数据库取值…… ……");
                        value = "张三";
                        safeHashMap.put(key,value);
                    }
                }finally {
                    rw.writeLock().unlock();
                }
                rw.readLock().lock();//写入缓存完毕后,重新获取读锁
            }else{
                System.out.println("从缓存中获取值…… ……");
            }
        }finally {
            rw.readLock().unlock();//释放读锁
        }
        return value==null ? null : String.valueOf(value);
    }

    public static void main(String[] str){
        ReadWriteCatch rwc = new ReadWriteCatch();
        for (int i=0;i<3;i++) {
            System.out.println(rwc.getKey("1"));
        }
    }
}

9.Future

在并发编程中,一般使用Runable执行异步任务,但是这样并不能拿到异步任务的返回值,但是Future可以,使用时,把Runable换成FutureTask即可。

10.ThreadLocal

10.1是什么:

  • 代表一个线程局部变量,每个线程都有一个副本,线程之间相互独立,只能看到自己的值,并不会意识到其他线程中也有该变量。
  • 采用空间换时间的方式,解决多线程间相同变量的冲突问题。

10.2原理:

  • 每个Thread对象,都有一个ThreadLocalMap,当创建ThreadLocal时,就会将该ThreadLocal对象添加到Map中,其中键是ThreadLocal,值可以是任意类型。
  • 在该类中,最重要是的是set()、get()两个方法,当调用get()方法时,会先找到当前线程的ThreadLocalMap,然后再找对应的值。
    get()找自己的副本变量。

10.3使用场景

  • 数据库连接池、session

10.4代码实现

  • ThreadLocal的接口方法:
    1.void set(Object value)
    2.public Object get()
    3.public void remove() 删除当前线程局部变量的值
    4.protected Object initalValue() 返回当前线程局部变量的初始值
public class Test {

    //初始化tl为0
   static ThreadLocal<Integer> tl = new ThreadLocal<Integer>(){
        protected Integer initialValue(){
            return 0;
        }
    };
    //设置副本+1
    public static Integer getNextTl(){
        tl.set(tl.get()+1);
        return tl.get();
    }
    //每组3个线程去读自己副本的值
    public static class ThreadClient extends Thread{
        public void run() {
            for(int i=0;i<3;i++){
                System.out.println("ThreadName:"+Thread.currentThread().getName()+",下个值:"+getNextTl());
            }
        }
    }
    //启动3个线程
    public static void main(String[] arg){
        ThreadClient t1 = new ThreadClient();
        ThreadClient t2 = new ThreadClient();
        ThreadClient t3 = new ThreadClient();
        t1.start();
        t2.start();
        t3.start();
    }
}

结果集:每组线程获取到的值互不影响

ThreadName:Thread-0,下个值:1
ThreadName:Thread-0,下个值:2
ThreadName:Thread-0,下个值:3
ThreadName:Thread-1,下个值:1
ThreadName:Thread-1,下个值:2
ThreadName:Thread-1,下个值:3
ThreadName:Thread-2,下个值:1
ThreadName:Thread-2,下个值:2
ThreadName:Thread-2,下个值:3

10.线程池

线程池通过线程复用大大减少了创建和销毁带来的性能上的损耗。

最后编辑于 :
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

  • Java8张图 11、字符串不变性 12、equals()方法、hashCode()方法的区别 13、...
    Miley_MOJIE阅读 4,009评论 0赞 11
  • 一、线程状态转换新建(New)可运行(Runnable)阻塞(Blocking)无限期等待(Waiting)限期等...
    达微阅读 819评论 1赞 2
  • 第三章 Java内存模型 3.1 Java内存模型的基础 通信在共享内存的模型里,通过写-读内存中的公共状态进行隐...
    泽毛阅读 4,550评论 2赞 21
  • 在一个方法内部定义的变量都存储在栈中,当这个函数运行结束后,其对应的栈就会被回收,此时,在其方法体中定义的变量将不...
    Y了个J阅读 4,645评论 1赞 14
  • 本文首发于我的个人博客:尾尾部落 本文是我刷了几十篇一线互联网校招java后端开发岗位的面经后总结的多线程相关题目...
    繁著阅读 2,218评论 0赞 7

友情链接更多精彩内容