• java线程安全

    (一)、java并发之原子性与可见性

    原子性

    原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。Java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。

    可见性

    可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如：用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题，volatile只能让被他修饰内容具有可见性，但不能保证它具有原子性。比如 volatile int a = 0；之后有一个操作 a++；这个变量a具有可见性，但是a++ 依然是一个非原子操作，也就这这个操作同样存在线程安全问题。

    他们之间关系

    原子性是说一个操作是否可分割，可见性是说操作结果其他线程是否可见。这么看来他们其实没有什么关系。

    volatile与synchronized关键字

    （1）volatile

    volatile赋予了变量可见——禁止编译器对成员变量进行优化，它修饰的成员变量在每次被线程访问时，都强迫从主存中重读该成员变量的值；而且，当成员变量发生变化时，强迫线程将变化值回写到共享主存，这样在任何时刻两个不同线程总是看到某一成员变量的同一个值，这就是保证了可见性。文摘：

    Java规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量
    的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而volatile关键字就是提示
    VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
    使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
    由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

    注意：如果给一个变量加上volatile修饰符，就相当于：每一个线程中一旦这个值发生了变化就马上刷新回主存，使得各个线程取出的值相同。编译器不要对这个变量的读、写操作做优化。但是值得注意的是，除了对long和double的简单操作之外，volatile并不能提供原子性。所以，就算你将一个变量修饰为volatile，但是对这个变量的操作并不是原子的，在并发环境下，还是不能避免错误的发生！

      参考链接： http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

    （2）synchronized

    synchronized为一段操作或内存进行加锁，它具有互斥性。当线程要操作被synchronized修饰的内存或操作时，必须首先获得锁才能进行后续操作；但是在同一时刻只能有一个线程获得相同的一把锁（对象监视器），所以它只允许一个线程进行操作。

    简单的理解方法：

    synchronized（object） method（）；

    这相当与为menthod（）加了一把锁，这把锁就是object对象，当线程要访问method方法时，需要获取钥匙：object的对象监视器，如果该钥匙没人拿走（之前没有线程操作该方法或操作完成），则当前线程拿走钥匙（获取对象监视器），并操作方法；当操作完方法后，将“钥匙”放回原处！

    如果“钥匙”不在原处，则该线程需要等待别人把钥匙放回来（等待即进入阻塞状态）；如果多个线程要获取该钥匙，则它们需要进行“竞争”（一般是根据线程的优先级进行竞争） 

      

    （二）、java并发之线程封闭

    线程封闭

    实现好的并发是一件困难的事情，所以很多时候我们都想躲避并发。避免并发最简单的方法就是线程封闭。什么是线程封闭呢？
    就是把对象封装到一个线程里，只有这一个线程能看到此对象。那么这个对象就算不是线程安全的也不会出现任何安全问题。实现线程封闭有哪些方法呢？

    1：ad-hoc线程封闭

             这是完全靠实现者控制的线程封闭，他的线程封闭完全靠实现者实现。也是最糟糕的一种线程封闭。所以我们直接把他忽略掉吧。

    2：栈封闭

            栈封闭是我们编程当中遇到的最多的线程封闭。什么是栈封闭呢？简单的说就是局部变量。多个线程访问一个方法，此方法中的
    局部变量都会被拷贝一分儿到线程栈中。所以局部变量是不被多个线程所共享的，也就不会出现并发问题。所以能用局部变量就别用全局的变量，全局变量容易引起并发问题。

    3：ThreadLocal封闭

          使用ThreadLocal是实现线程封闭的最好方法，有兴趣的朋友可以研究一下ThreadLocal的源码，其实ThreadLocal内部维护了一个Map，Map的key是每个线程的名称，而Map的值就是我们要封闭的对象。每个线程中的对象都对应着Map中一个值，也就是ThreadLocal利用Map实现了对象的线程封闭。这里就不说ThreadLocal的使用方法了，度娘一下便知。 

    总之，当我们要用线程封闭来避免并发问题的时候，最好使用的就是 【栈封闭】 和 【ThreadLocal】。

     

    （三）、java并发之工具类的使用

    Java中提供了一些工具类和容器类 来帮助我们来更好的实现并发。这篇博文我们就来简单讨论一下java中的工具类和容器类。学会并且熟练使用这些工具类对java的并发有很大的帮助。

    工具类

    Future与Callable相关类

    异步执行计算结果，在计算完成之前get方法会一直等待。一旦计算完成，就不能再重新开始或取消计算。可使用 FutureTask 包装 Callable 或 Runnable 对象

    [java] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. package com.chu.test.current;  
    2. import java.util.concurrent.Callable;  
    3. import java.util.concurrent.ExecutionException;  
    4. import java.util.concurrent.FutureTask;  
    5. public class TestFutureTask {  
    6.     public static void main(String[] args) throws InterruptedException, ExecutionException {  
    7.         FutureTask<String>  ft  = new FutureTask<String>(new Callable<String>(){  
    8.             @Override  
    9.             public String call() throws Exception {  
    10.                 return "aaaaa";  
    11.             }  
    12.         });  
    13.         new Thread(ft).start();  
    14.         while(!ft.isDone()){  
    15.             System.out.println("增在计算结果...");  
    16.         }  
    17.         System.out.println(ft.get());  
    18.     }  
    19. }  

    CountDownLatch

    一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 他的实现方法就是一个计数器，在初始化CountDownLatch的时候定下来计数器的数量。每次调用countDown方法，计数器的数量就会减1，在计数器为0之前await方法会一直等待。

    [java] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. package com.chu.test.current;  
    2. import java.util.concurrent.CountDownLatch;  
    3. public class TestCountDownLatch {  
    4.     public static void main(String[] args) throws InterruptedException {  
    5.         final CountDownLatch cdl = new CountDownLatch(1);  
    6.         new Thread() {  
    7.             @Override  
    8.             public void run() {  
    9.                 try {  
    10.                     System.out.println("等待执行...");  
    11.                     cdl.await();//在countDown执行之前会一直等待  
    12.                     System.out.println("执行完成。");  
    13.                 } catch (InterruptedException e) {  
    14.                     e.printStackTrace();  
    15.                 }  
    16.             }  
    17.         }.start();  
    18.         Thread.sleep(5000);  
    19.         cdl.countDown();  
    20.     }  
    21. }   

    Semaphore

    一个计数信号量。 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

    [java] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. package com.chu.test.current;  
    2. import java.util.concurrent.ExecutorService;  
    3. import java.util.concurrent.Executors;  
    4. import java.util.concurrent.Semaphore;  
    5. public class TestSemaphore {  
    6.     public static void main(String... args) {  
    7.         ExecutorService exec = Executors.newCachedThreadPool();  
    8.         final Semaphore semp = new Semaphore(3);  
    9.         for (int index = 0; index < 5; index++) {  
    10.             final int NO = index;  
    11.             Runnable run = new Runnable() {  
    12.                 public void run() {  
    13.                     try {  
    14.                         // 获取许可  
    15.                         semp.acquire();  
    16.                         System.out.println("Accessing: " + NO);  
    17.                         Thread.sleep(2000);  
    18.                         // 访问完后，释放  
    19.                         semp.release();  
    20.                         System.out.println("-----------------" + semp.availablePermits());  
    21.                     } catch (InterruptedException e) {  
    22.                         e.printStackTrace();  
    23.                     }  
    24.                 }  
    25.             };  
    26.             exec.execute(run);  
    27.         }  
    28.     }  
    29. }  


     

    CyclickBarrier

    CyclicBarrier就象它名字的意思一样，可看成是个障碍，所有的线程必须到齐后才能一起通过这个障碍。

    [java] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. package com.chu.test.current;  
    2. import java.util.concurrent.BrokenBarrierException;  
    3. import java.util.concurrent.CyclicBarrier;  
    4. public class TestCyclicBarrier {  
    5.     public static void main(String[] args) {  
    6.         CyclicBarrier cb = new CyclicBarrier(4);  
    7.         new Thread(new Work(cb,"A")).start();  
    8.         new Thread(new Work(cb,"B")).start();  
    9.         new Thread(new Work(cb,"C")).start();  
    10.         new Thread(new Work(cb,"D")).start();  
    11.     }  
    12. }  
    13. class Work implements Runnable{  
    14.     CyclicBarrier cb;  
    15.     String name;  
    16.     public Work(CyclicBarrier cb , String name){  
    17.         this.cb = cb;  
    18.         this.name = name;  
    19.     }  
    20.     @Override  
    21.     public void run() {  
    22.         System.out.println(name+"准备工作...");  
    23.         try {  
    24.             cb.await();  
    25.         } catch (InterruptedException e) {  
    26.             e.printStackTrace();  
    27.         } catch (BrokenBarrierException e) {  
    28.             e.printStackTrace();  
    29.         }  
    30.         System.out.println(name+"开始工作...");  
    31.     }  
    32. }   

    Exchanger

    用于交换两个线程的信息。

    [java] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. package com.chu.test.current;  
    2. import java.util.concurrent.Exchanger;  
    3. public class TestExchanger {  
    4.     public static void main(String[] args) {  
    5.         Exchanger<String> ex = new Exchanger<String>();  
    6.         new Thread(new Change(ex,"A")).start();  
    7.         new Thread(new Change(ex,"B")).start();  
    8.     }  
    9. }  
    10. class Change implements Runnable{  
    11.     Exchanger<String> ex;  
    12.     String name;  
    13.     public Change(Exchanger<String> ex,String name){  
    14.         this.ex = ex;  
    15.         this.name = name;  
    16.     }  
    17.     @Override  
    18.     public void run() {  
    19.         System.out.println(Thread.currentThread().getName()+"来了");  
    20.         System.out.println(Thread.currentThread().getName()+"准备把【"+name+"】换出去");  
    21.         try {  
    22.             String new_name = ex.exchange(name);  
    23.             System.out.println(Thread.currentThread().getName()+"把【"+new_name+"】换回来");  
    24.         } catch (InterruptedException e) {  
    25.             e.printStackTrace();  
    26.         }  
    27.     }  
    28. }  


     

    容器类

    这里只简单的列举一下常见的同步容器类，他们的用法和非同步的容器类大同小异，这里就不举例说明他们的用法。可以度娘一下应有尽有。

    同步List

    CopyOnWriteArrayList：是ArrayList线程安全的变体，其中引起此list改变的操作（add，remove）都是通过对底层数组进行一次新的复制来实现的。这一般需要很大的开销。但是当遍历操作大大超过可变操作时，这种方法比其他方法更有效。不会抛出ConcurrentModificationException。

    同步Map

    HashTable：比较古老的同步Map
    ConcurrentHashMap：是HashMap的同步版本，是1.5新增的同步类，不会抛ConcurrentModificationException，并且key无序排列。
    ConcurrentSkipListMap：映射可以根据键的自然顺序进行排序，也可以根据创建映射时所提供的Comparator 进行排序，具体取决于使用的构造方法。

    同步Set

    CopyOnWriteArraySet ：内部使用CopyOnWriteArrayList 实现。
    ConcurrentSkipListSet：内部使用ConcurrentSkipListMap实现。

    同步队列

    ArrayBlockingQueue ：一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序
    LinkedBlockingQueue ：一个基于已链接节点的、任选范围的阻塞双端队列。
    PriorityBlockingQueue ：一个无界阻塞队列，它使用与类PriorityQueue 相同的顺序规则，并且提供了阻塞获取操作。虽然此队列逻辑上是无界的，但是资源被耗尽时试图执行 add 操作也将失败（导致OutOfMemoryError）。此类不允许使用 null 元素。依赖自然顺序的优先级队列也不允许插入不可比较的对象（这样做会导致抛出ClassCastException）。 
    ConcurrentLinkedQueue：一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。非阻塞。 

    Collctions返回的同步容器

    synchronizedList(List<T> list) 、synchronizedMap(Map<K,V> m) 、synchronizedSet(Set<T> s) 通过这些方法返回的容器，都是线程安全的容器，有一点需要注意的就是这些同步容器在迭代的时候，比如手工加同步，例

    synchronized（list）{...}否则会产生不可预料的结果。

     
  • 相关阅读:
    Razor 视图
    可选参数和命名参数
    CPU性能分析工具原理
    从硬件到语言，详解C++的内存对齐（memory alignment）
    谈谈C++的volatile关键字以及常见的误解
    C++11的value category（值类别）以及move semantics（移动语义）
    C++基于范围循环（range-based for loop）的陷阱
    C++模板入门教程（一）——模板概念与基本语法
    自己动手实现深度学习框架-8 RNN文本分类和文本生成模型
    自己动手实现深度学习框架-7 RNN层--GRU, LSTM
  • 原文地址：https://www.cnblogs.com/wytiger/p/5572009.html
Copyright © 2020-2023  润新知