并发编程(六):线程安全性

内容预览:
  •   什么是线程安全的类?   当多个线程访问某个类时,不管运行...~
  •   提起有序性,我们可以想到JMM(java内存模型)中一个非常重要的...~
  •           ~

  什么是线程安全的类?

  当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些进程将如何交替执行,并且在主调代码中不需要额外同步或协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的

 

  线程安全性包含哪些特性?

  原子性:提供了互斥访问,同一时刻只能有一个线程对它进行操作

  可见性:一个线程对主内存的修改可以及时被其他线程观察到

  有序性:一个线程观察其他线程的指令执行顺序,由于指令重排序的存在,该观察结果一般杂乱无序。

 

  原子性

  保证原子性的手段通常有以下几种

  当需要同步时,可能我们首先想到的就是synchronized,但是在竞争特别激烈时,synchronized可能并不是很好的选择,synchronized的使用方式大概有以下几种

  关于atomic,我们在前面的博客中已有实例应用,关于Lock的使用我们会在后面的博客中做专门的讲解,下面我们简单看一下synchronized的demo

  synchronized-demo1(修饰方法)

@Slf4j
public class SynchronizedExample1 {

//修饰一个代码块
public void test1(int j) {
synchronized (this) {
for (int i = 0; i < 10; i++) {
log.info(
"test1-{}-{}", j,i);
}
}
}

//修饰一个方法
public synchronized void test2(int j) {
for (int i = 0; i < 10; i++) {
log.info(
"test2-{}-{}", j,i);
}
}

public static void main(String[] args) {
SynchronizedExample1 example1
= new SynchronizedExample1();
SynchronizedExample1 example2
= new SynchronizedExample1();
ExecutorService executorService
= Executors.newCachedThreadPool();
executorService.execute(()
->{
example1.test2(
1);
});

executorService.execute(()
->{
example2.test2(
2);
});

}

}

 

  synchronized-demo2(修饰类)

@Slf4j
public class SynchronizedExample2 {

//修饰一个类
public static void test1(int j) {
synchronized (SynchronizedExample2.class) {
for (int i = 0; i < 10; i++) {
log.info(
"test1-{}-{}", j,i);
}
}
}

//修饰一个静态方法
public static synchronized void test2(int j) {
for (int i = 0; i < 10; i++) {
log.info(
"test2-{}-{}", j,i);
}
}

public static void main(String[] args) {
SynchronizedExample2 example1
= new SynchronizedExample2();
SynchronizedExample2 example2
= new SynchronizedExample2();
ExecutorService executorService
= Executors.newCachedThreadPool();
executorService.execute(()
->{
example1.test1(
1);
});

executorService.execute(()
->{
example2.test1(
2);
});

}

}

 

  可见性

  导致共享变量在线程间不可见的原因

  通常我们有两种方式来保证可见性:

  a、synchronized

  java内存模型中关于synchronized有两条规定

  1、线程解锁前,必须把共享变量的最新值刷新到主内存

  2、线程加锁时将清空工作内存中共享变量的值,从而使用共享变量时需要从主内存中重新读取最新的值(加锁与解锁必须是同一把锁)

 

  b、volatile

  volatile通过加入内存屏障和禁止重排序优化来实现可见性

  a、对volatile变量写操作时,会在写操作后加一条store屏障指令,将本地内存中的共享变量值刷新到主内存

  b、对volatile变量读操作时,会在读操作前加入一条load屏障指令,从主内存读取共享变量

 

  volatile写:

 

  volatile读:

 

  有序性

  java内存模型中,允许编译器和处理器对指令进行重排序,重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性,有序性可依靠volatile、synchronized、Lock来保证。

  提起有序性,我们可以想到JMM(java内存模型)中一个非常重要的原则-happens-before原则:

  a、程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作

  b、锁定操作:一个unLock操作先行发生于后面对同一个锁的lock操作

  c、volatile变量规则:对一个变量的写操作先行发生于后面这个变量的读操作

  d、传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C

  e、线程启动规则:Thread对象的start()方法先行发生于此线程的每一个动作

  f、线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生

  g、线程终结规则:线程中所有操作都先行发生于线程的终止检测,可有通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

  h、对象终结规则:一个对象的初始化完成先行发生于他的finalize()(GC在回收对象之前调用该方法)方法的开始

 

  如果两个操作的执行次序,无法从happends-before原则推到出来,就不能保证有序性,虚拟机可随意的对他们进行重排序。

 

 

 

 

  

以上就是:并发编程(六):线程安全性 的全部内容。

本站部分内容来源于互联网和用户投稿,如有侵权请联系我们删除,谢谢。
Email:[email protected]


0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论