zoukankan      html  css  js  c++  java
  • Effective Java 66 Synchronize access to shared mutable data

    synchronized - Only a single thread can execute a method or block at one time.  

    Not only does synchronization prevent a thread from observing an object in an inconsistent state, but it ensures that each thread entering a synchronized method or block sees the effects of all previous modifications that were guarded by the same lock. 

    Synchronization is required for reliable communication between threads as well as for mutual exclusion. 

    Principles 

    1. Do not use Thread.stop. 

    2. Synchronization has no effect unless both read and write operations are synchronized. 

    /** 

     * Demo for 66 Synchronize access to shared mutable data. 

     */ 

    package com.effectivejava.concurrency; 

     

    import java.util.concurrent.TimeUnit; 

     

    /** 

     * Properly synchronized cooperative thread termination 

     * @author Kaibo 

     *  

     */ 

    public class StopThread { 

    private static boolean stopRequested;

    private static synchronized void requestStop() { 

    stopRequested = true; 

    System.out.println("request stop from another thread."); 

    }  

    private static synchronized boolean stopRequested() { 

    return stopRequested; 

    } 

     

     

    public static void main(String[] args) throws InterruptedException { 

    Thread backgroundThread = new Thread(new Runnable() { 

    public void run() { 

    int i = 0; 

    while (!stopRequested()) 

    System.out.println(i++); 

    } 

    }); 

    backgroundThread.start(); 

    TimeUnit.SECONDS.sleep(1); 

    requestStop(); 

    } 

    } 

     

    /** 

     * Cooperative thread termination with a volatile field 

     *  

     * @author Kaibo 

     *  

     */ 

    public class StopThreadWithVolatile { 

    private static volatile boolean stopRequested; 

     

    public static void main(String[] args) throws InterruptedException { 

    Thread backgroundThread = new Thread(new Runnable() { 

    public void run() { 

    int i = 0; 

    while (!stopRequested) 

    System.out.println(i++); 

    } 

    }); 

    backgroundThread.start(); 

    TimeUnit.SECONDS.sleep(1); 

    stopRequested = true; 

    } 

    } 

    NOTE  

    operator(++) is not atomic - If a second thread reads the field between the time a thread reads the old value and writes back a new one, the second thread will see the same value as the first and return the same serial number. 

     

    // Broken - requires synchronization! 

    private static volatile int nextSerialNumber = 0; 

    public static int generateSerialNumber() { 

    return nextSerialNumber++; 

    } 

     

    // Correct way 

    private static final Atomic Long nextSerialNum = new AtomicLong(); 

    public static long generateSerialNumber() { 

    return nextSerialNum.getAndIncrement(); 

    } 

    4. Confine mutable data to a single thread  

    Summary 

    When multiple threads share mutable data, each thread that reads or writes the data must perform synchronization. Without synchronization, there is no guarantee that one thread’s changes will be visible to another. The penalties for failing to synchronize shared mutable data are liveness and safety failures. If you need only inter-thread communication, and not mutual exclusion, the volatile modifier is an acceptable form of synchronization, but it can be tricky to use correctly.

  • 相关阅读:
    MFC编程习惯
    光源的频闪与常亮
    相机的选择——卷帘快门(Rolling Shutter)与全局快门(Global Shutter)
    Halcon标定(以40*40标定板为例)
    DALSA线阵相机使用教程(以16K为例)、保存配置文件ccf细节
    打包exe(使用Inno Setup)
    机器视觉项目总结——镜头
    Qt(MinGW版本)utf8终端中文乱码解决方案
    Qt(MinGW版本)安装
    (C#)Windows Shell 外壳编程系列7
  • 原文地址:https://www.cnblogs.com/haokaibo/p/synchronize-access-to-shared-mutable-data.html
Copyright © 2011-2022 走看看