您现在的位置是:首页 > 文章详情

并发编程专题七-什么是线程安全

日期:2019-05-12点击:264

文档章节

一、什么是类的线程安全  

既然今天的主题是线程安全,那什么是线程安全呢?

其实线程安全并没有一个明确的定义,Doug Lea大师(不认识的去百度,java不认识的去面壁)给下的定义为多线程下使用这个类,不过多线程如何使用和调度这个类,这个类总是表示出正确的行为,这个类就是线程安全的。

类的线程安全表现为:

  1. 操作的原子性
  2. 内存的可见性

不做正确的同步,在多个线程之间共享状态的时候,就会出现线程不安全。

1、操作的原子性

原子性在之前的篇章都有讲过,就不细说了。主要就是表示一个操作是不可中断的,或者不可在分割的,要么全部执行成功要么全部执行失败。

2、内存的可见性

多个线程对同一个变量(称为:共享变量)进行操作,但是这多个线程有可能被分配到多个处理器中运行,那么编译器会对代码进行优化,当线程要处理该变量时,多个处理器会将变量从主存复制一份分别存储在自己的存储器中,等到进行完操作后,再赋值回主存。

这样做的好处是提高了运行的速度,同样优化带来的问题之一是变量可见性——如果线程t1与线程t2分别被安排在了不同的处理器上面,那么t1与t2对于变量A的修改时相互不可见,如果t1给A赋值,然后t2又赋新值,那么t2的操作就将t1的操作覆盖掉了,这样会产生不可预料的结果。因此,需要保证变量的可见性(一个线程对共享变量值的修改,能够及时地被其它线程看到)。

多线程操作共享变量实现可见性过程JVM的内存模型如下:

  

因此,如果要保证线程安全,那就要保证,我们所有的线程读取到的共享变量都是正确的值,也就是保证内存的可见性。

二、让类的做到线程安全的方式

2.1、栈封闭

如果了解JVM的同学应该都清楚,java中定义的每个方法,存储在java的方法栈中,每个方法是一个栈桢,所谓的栈封闭,就是变量在方法内部进行声明。那么这些变量都是处于栈封闭状态的。(说简单点就是定义局部变量)

code:

 /** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:栈封闭 */ public class WorkTask { //不安全 private String name; public Integer call() { //方法内的成员变量是安全的, String name ="safe"; this.name = name; int sleepTime = new Random().nextInt(1000); try { Thread.sleep(sleepTime); } catch (InterruptedException e) { e.printStackTrace(); } return sleepTime; } }

2.2、无状态

就是没有实例变量的对象  ,没有具体字段,不能保存数据,是不变类。例如我们MVC模式中的DAO层。只定义方法,没有定义字段变量。

 /** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:没有任何变量,线程安全 */ public class WorkTask { public Integer call() { String name ="safe"; int sleepTime = new Random().nextInt(1000); try { Thread.sleep(sleepTime); } catch (InterruptedException e) { e.printStackTrace(); } return sleepTime; } }

2.3、让类不可变

除了将类定义成无状态之外,但大多数情况下,我们的类都是有字段的,有状态的,那就需要通过让类不可变的方式,让类变得安全。方式有以下两种

(1),加final关键字,但是加上final,要注意如果成员变量又是一个对象时,这个对象所对应的类也要是不可变,才能保证整个类是不可变的。

code:

package com.xiangxue.ch7.safeclass; /** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description: 不可变的类 */ public class ImmutableFinalRef { //因为a,b都是final变量,不可变,顾属于安全的。 private final int a; private final int b; //这里,就不能保证线程安全啦,因为user是一个引用类型,user对象里的字段有可能进行改变, //除非user对象里所有字段也都是final类型,否则User其实是可变的。 private final User user; public ImmutableFinalRef(int a, int b) { super(); this.a = a; this.b = b; this.user = new User(2); } public int getA() { return a; } public int getB() { return b; } public User getUser() { return user; } //将User内部所有字段改为final,则能保证改类为线程安全。 public static class User{ private int age; public User(int age) { super(); this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public static void main(String[] args) { ImmutableFinalRef ref = new ImmutableFinalRef(12,23); User u = ref.getUser(); } } 

(2)、根本就不提供任何可供修改成员变量的地方,同时成员变量也不作为方法的返回值

code:

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:不可变的类 */ public class ImmutetableToo { //改类也属于线程安全的,因为没有提供任何获取和修改的地方。 private List<Integer> list = new ArrayList<>(3); public ImmutetableToo() { list.add(1); list.add(2); list.add(3); } public boolean isContains(int i) { return list.contains(i); } }

java开发建议:对于一个类,所有的成员变量应该是私有的,如果有可能,所有的成员变量应该加上final关键字.可以保证线程安全。

2.4、volatile

volatile关键字可以保证保证类的可见性,最适合一个线程写,多个线程读的情景,

2.5、加锁和CAS

恩,这个没啥好解释的了。。。。

2.6、安全的发布

类中持有的成员变量,特别是对象的引用,如果这个成员对象不是线程安全的,通过get等方法发布出去,会造成这个成员对象本身持有的数据在多线程下不正确的修改,从而造成整个类线程不安全的问题。

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:存在不安全的发布 */ public class UnsafePublish { //要么用线程安全的容器替换 //要么发布出去的时候,提供副本,深度拷贝 private List<Integer> list = new ArrayList<>(3); public UnsafePublish() { list.add(1); list.add(2); list.add(3); } //将list不安全的发布出去了,线程不安全。 public List<Integer> getList() { return list; } //也是安全的,加了锁-------------------------------- public synchronized int getList(int index) { return list.get(index); } public synchronized void set(int index,int val) { list.set(index,val); } }

2.7、TheadLocal

ThreadLocal的实例代表了一个线程局部的变量,每条线程都只能看到自己的值,并不会意识到其它的线程中也存在该变量。

三、线程安全引发的一些问题

3.1、死锁

死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。

发生死锁的条件是,竞争资源一定是多于1个,同时小于等于竞争的线程数,当资源只有一个,只会产生激烈的竞争,不会死锁。

死锁的根本成因:获取锁的顺序不一致导致。

code:

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:死锁的例子 */ public class NormalDeadLock { private static Object lockFirst = new Object();//第一个锁 private static Object lockSecond = new Object();//第二个锁 //先拿第一个锁,再拿第二个锁 private static void fisrtToSecond() throws InterruptedException { String threadName = Thread.currentThread().getName(); synchronized (lockFirst) { System.out.println(threadName+" get first"); SleepTools.ms(100); synchronized (lockSecond) { System.out.println(threadName+" get second"); } } } //先拿第二个锁,再拿第一个锁 private static void SecondToFisrt() throws InterruptedException { String threadName = Thread.currentThread().getName(); synchronized (lockFirst) { System.out.println(threadName+" get first"); SleepTools.ms(100); synchronized (lockSecond) { System.out.println(threadName+" get second"); } } } //执行先拿第二个锁,再拿第一个锁 private static class TestThread extends Thread{ private String name; public TestThread(String name) { this.name = name; } public void run(){ Thread.currentThread().setName(name); try { SecondToFisrt(); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { Thread.currentThread().setName("TestDeadLock"); TestThread testThread = new TestThread("SubTestThread"); testThread.start(); try { fisrtToSecond();//先拿第一个锁,再拿第二个锁 } catch (InterruptedException e) { e.printStackTrace(); } } }

3.1.1查找程序是否死锁的方式

1、代码逻辑查看

2、通过通过jps 查询应用的 id,再通过jstack id 查看应用的锁的持有情况,高版本的JDK可以直接检测到简单地死锁

解决办法:保证加锁的顺序性

3.1.2动态的死锁

动态顺序死锁,在实现时按照某种顺序加锁了,但是因为外部调用的问题,导致无法保证加锁顺序而产生的。

code:

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:不安全的转账动作的实现 */ public class TrasnferAccount implements ITransfer { //当根据传参不一致,有可能会导致死锁。 //一个线程先锁了from,在锁了to同时另一个线程将to当做from传参, // 将from当做to传参。那么第二个线程则先锁了to,又锁了from。导致死锁 @Override public void transfer(UserAccount from, UserAccount to, int amount) throws InterruptedException { synchronized (from){//先锁转出 System.out.println(Thread.currentThread().getName() +" get"+from.getName()); Thread.sleep(100); synchronized (to){//再锁转入 System.out.println(Thread.currentThread().getName() +" get"+to.getName()); from.flyMoney(amount); to.addMoney(amount); } } } }

解决:

  1. 通过内在排序,保证加锁的顺序性
  2. 通过尝试拿锁,也可以。

3.2、活锁

例如我们生活中的例子,两个人在窄路相遇,同时向一个方向避让,然后又向另一个方向避让,如此反复。导致两个人都过不去。

活锁即是在尝试拿锁的机制中,发生多个线程之间互相谦让,不断发生拿锁,释放锁的过程。

解决办法:每个线程休眠随机数,错开拿锁的时间。

3.3、线程饥饿

低优先级的线程,总是拿不到执行时间。

3.4、性能和思考

使用并发的目标是为了提高性能,引入多线程后,其实会引入额外的开销,如线程之间的协调、增加的上下文切换,线程的创建和销毁,线程的调度等等。过度的使用和不恰当的使用,会导致多线程程序甚至比单线程还要低。

衡量应用的程序的性能:服务时间,延迟时间,吞吐量,可伸缩性等等,其中服务时间,延迟时间(多快),吞吐量(处理能力的指标,完成工作的多少)。多快和多少,完全独立,甚至是相互矛盾的。

对服务器应用来说:多少(可伸缩性,吞吐量)这个方面比多快更受重视,先保证可以横向扩展,在保证垂直扩展。

我们做应用的时候:

  1. 先保证程序正确,确实达不到要求的时候,再提高速度。(黄金原则)
  2. 一定要以测试为基准。

一个应用程序里,串行的部分是永远都有的。

Amdahl定律  :  1/(F+(1-N)/N)   F:必须被串行部分,程序最好的结果为 1/F。

3.5、影响性能的因素

3.5.1、上下文切换

是指CPU 从一个进程或线程切换到另一个进程或线程。一次上下文切换花费5000~10000个时钟周期,几微秒。在上下文切换过程中,CPU会停止处理当前运行的程序,并保存当前程序运行的具体位置以便之后继续运行。从这个角度来看,上下文切换有点像我们同时阅读几本书,在来回切换书本的同时我们需要记住每本书当前读到的页码。

上下文切换通常是计算密集型的。也就是说,它需要相当可观的处理器时间。所以,上下文切换对系统来说意味着消耗大量的 CPU 时间,事实上,可能是操作系统中时间消耗最大的操作。

3.5.2、内存同步

一般指加锁,对加锁来说,需要增加额外的指令,这些指令都需要刷新缓存等等操作。

3.5.3、阻塞

会导致线程挂起【挂起:挂起进程在操作系统中可以定义为暂时被淘汰出内存的进程,机器的资源是有限的,在资源不足的情况下,操作系统对在内存中的程序进行合理的安排,其中有的进程被暂时调离出内存,当条件允许的时候,会被操作系统再次调回内存,重新进入等待被执行的状态即就绪态,系统在超过一定的时间没有任何动作】。很明显这个操作包括两次额外的上下文切换。

3.6、如何减少锁的竞争

3.6.1、减少锁的粒度

使用锁的时候,锁所保护的对象是多个,当这些多个对象其实是独立变化的时候,不如用多个锁来一一保护这些对象。但是如果有同时要持有多个锁的业务方法,要注意避免发生死锁

code

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description: */ public class FinenessLock { public final Set<String> users = new HashSet<String>(); // 锁的粒度过大,在执行方法体是就进行加锁 // public void synchronized addUser(String u) { // System.out.println("test"); // users.add(u); // } //只针对对操作的对象进行加锁,如果方法体重还有其他方法,则不影响其他业务进行。 public void addUser(String u) { System.out.println("test"); synchronized (users) { users.add(u); } } }

加锁原则,能加锁对象别锁方法,能锁方法不要锁类。锁类尽量不要使用

3.6.2、缩小锁的范围

对锁的持有实现快进快出,尽量缩短持由锁的的时间。将一些与锁无关的代码移出锁的范围,特别是一些耗时,可能阻塞的操作

code:

/** * @Auther: DarkKing * @Date: 2019/5/12 12:09 * @Description:缩小锁的范围 */ public class ReduceLock { private Map<String,String> matchMap = new HashMap<>(); //加锁体力过多无关线程安全的操作 public boolean isMatch(String name,String regexp) { synchronized(this){ String key = "user."+name; String job = matchMap.get(key); if(job == null) { return false; }else { return Pattern.matches(regexp, job);//很耗费时间 } } } //只对有可能发生线程安全问题的操作进行加锁 public boolean isMatchReduce(String name,String regexp) { String key = "user."+name; String job ; synchronized(this) { job = matchMap.get(key); } if(job == null) { return false; }else { return Pattern.matches(regexp, job); } } }

3.6.3、避免多余的缩减锁的范围

两次加锁之间的语句非常简单,导致加锁的时间比执行这些语句还长,这个时候应该进行锁粗化—扩大锁的范围。

3.6.4、锁分段

ConcurrrentHashMap就是典型的锁分段。下一篇会进行ConcurrrentHashMap源码进行分析。

3.6.5、替换独占锁

在业务允许的情况下:

  1. 使用读写锁,
  2. 用自旋CAS
  3. 使用系统的并发容器

本章重点,了解什么是线程安全,实现类线程安全的几种方式,线程安全可能会引发什问题以及性能瓶颈如何去解决和优化。下一章将会对java里的一些并发容器介绍,以及源码进行分析。

今天送波福利电子书,大家有兴趣可以下载哦。

链接:https://pan.baidu.com/s/1oTHGDw-7_A8Yhn5MzpuDNA 
提取码:g5h1 

其他阅读   并发编程专题

有什么问题可以留言或者扫下方二维码,加我微信进行沟通哦。

481021518c4b8fa00ba60ef9609c53b2b5f.jpg

原文链接:https://my.oschina.net/u/3694479/blog/3048657
关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。

文章评论

共有0条评论来说两句吧...

文章二维码

扫描即可查看该文章

点击排行

推荐阅读

最新文章