Core Java Tutorial -- Thread Safety and Java Synchronization

太过爱你忘了你带给我的痛 2022-05-28 06:25 132阅读 0赞

Java 中的线程安全是一个重要的主题。Java 提供多线程环境支持 Java 线程，我们知道多线程由同一个 Object 创建共享对象变量，并且当线程用于读取和更新共享数据，可能会导致数据不一致。

# Thread Safety #

数据不一致的原因是因为更新任何字段的值不是一个原子操作，它需要三个步骤：首先获取当前值、其次要做必要的操作以获取更新的值，第三步将更新的值分配给字段引用。

让我们来用一个简单的程序来看这个问题，其中多个线程正在更新共享数据。

package Thread;
    
    public class ThreadSafety { 
    
        public static void main(String[] args) {
            ProcessingThread processingThread = new ProcessingThread();
            Thread t1 = new Thread(processingThread);
            t1.start();
            Thread t2 = new Thread(processingThread);
            t2.start();
    
            // wait for threads to finish processing
            try {
                t1.join();
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("Processing count = " + processingThread.getCount());
        }
    
    }
    
    class ProcessingThread implements Runnable { 
        private int count;
    
    
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                processSomething(i);
                count++;
            }
        }
    
        public int getCount() {
            return count;
        }
    
        private void processSomething(int i) {
            // processing some job
            try {
                Thread.sleep(i * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

上面的循环程序中，count 增加了 4 倍，并且由于我们由两个线程，所以线程完成执行后值应该是 8。但是当你多次运行程序时，你会发现计数值在 6 7 8 之间变化。发生这种情况是因为即使 count ++ 看起来是一个原子操作，其实并不是并且会导致数据损坏。

# Thread Safety in Java #

Java 中的线程安全，是让我们的程序在多线程环境中安全使用的过程，我们可以通过不同的方式使我们的程序线程安全。

*  Synchronization 是 Java 线程安全最简单并且最广泛使用的工具。
 *  使用 `java.util.concurrent.atomic` 包的原子包装类。栗如 `AtomicInteger`。
 *  使用 `java.util.concurrent.locks` 包中的锁。
 *  使用线程安全集合类，查看 [ConcurrentHashMap][] 文章。
 *  volatle 关键字与变量一起使用，使每个线程都从内存中读取数据，而不是从线程缓存中读取数据。

## Java synchronized ##

同步是我们可以实现线程安全的工具，JVM 保证同步代码一次只能由一个线程执行。Java 关键字 synchonized 用于创建同步代码，并在内部使用 Object 或 Class 上的锁来确保只有一个线程正在执行同步代码。

*  Java 同步对资源的锁定和解锁起作用，在任何线程进入同步代码之前，必须获取对象的锁定，并且在代码执行结束时，解锁可被其他线程锁定的资源。同时其他线程处于等待状态以锁定同步资源。
 *  我们可以通过两种方式使用 synchronized 关键字，一种是使完整的方法同步，另一种使创建同步块。
 *  当一个方法是 synchronized，它锁定 Object，如果方法是静态的，它会锁定 Class，所以最好使用 synchronized 块来锁定需要同步的方法的唯一部分。
 *  当创建同步块时，我们需要提供获取锁的资源，它可以是 XYZ.class 或类的任何对象字段。
 *  `synchronized(this)` 将在进入同步块之前锁定对象。
 *  你应该使用最低级别的锁定，栗如，如果某个类中由多个同步块，并且其中一个锁定了对象，则其他同步块也将不可供其他线程执行。当我们锁定一个对象时，它会获取该对象所有字段的锁定。
 *  Java 同步损失性能来提供数据完整性，因此只有在绝对必要时才应使用它。
 *  Java 同步只能在同一个 JVM 中工作，所以如果你需要在多个JVM环境中锁定一些资源，它将不起作用，你可能不得不照看一些全局锁定机制。
 *  Java 同步可能导致死锁，请查看 (Java 死锁以及如何避免)\[[https://www.journaldev.com/1058/deadlock-in-java-example\]][https_www.journaldev.com_1058_deadlock-in-java-example]
 *  Java synchronized 关键字不能被用于构造函数和变量。
 *  最好创建一个用于同步块的虚拟私有对象，以便它的引用不能被任何其他代码修改。栗如：如果你有一个你正在同步的 Object 的 setter 方法，那么它的引用可以被一些其他的代码导致并行执行 synchronized 块。
 *  我们不应该使用在常量池中维护的任何对象，栗如，字符串不应该用于同步，因为如果任何其他代码也锁定在同一个字符串上，它将尝试从[字符串池][Link 1]获取相同引用对象的锁定，并且即使两个代码无关，他们也会互相锁定。

下面是我们在上面的程序中需要做的代码更改，以使它线程安全。

//dummy object variable for synchronization
    private Object mutex=new Object();
    ...
    //using synchronized block to read, increment and update count value synchronously
    synchronized (mutex) {
        count++;
    }

让我们看看一些同步的例子，我们可以从中学到什么。

public class MyObject { 
    
      // Locks on the object's monitor
      public synchronized void doSomething() { 
        // ...
      }
    }
    
    // Hackers code
    MyObject myObject = new MyObject();
    synchronized (myObject) {
      while (true) {
        // Indefinitely delay myObject
        Thread.sleep(Integer.MAX_VALUE); 
      }
    }

注意，Hackers code 试图锁定 myObject 实例，一旦它获得锁定，它就不会释放它，从而导致doSomething() 方法在等待锁定时阻塞，这会导致系统进入死锁并导致 Denial of Service（DoS）。

public class MyObject {
      public Object lock = new Object();
    
      public void doSomething() {
        synchronized (lock) {
          // ...
        }
      }
    }
    
    //untrusted code
    
    MyObject myObject = new MyObject();
    //change the lock Object reference
    myObject.lock = new Object();

注意 lock 对象是公共的，通过改变它的引用，我们可以在多个线程中执行并行块同步。类似的情况，如果你有私有对象，但有 setter 方法来改变它的引用。

public class MyObject { 
      //locks on the class object's monitor
      public static synchronized void doSomething() { 
        // ...
      }
    }
    
    // hackers code
    synchronized (MyObject.class) {
      while (true) {
        Thread.sleep(Integer.MAX_VALUE); // Indefinitely delay MyObject
      }
    }

请注意，hackers code 正在获取类监视器上的锁定而不释放它，这将导致系统中的死锁和 DoS 。

这里是另一个例子，其中多个线程在相同的字符串数组上工作，并且一旦处理完毕，将线程名称附加到数组值。

package Thread;
    
    import java.util.Arrays;
    
    public class SynchronizedMethod {
        public static void main(String[] args) throws InterruptedException {
            String[] arr = {
       "1", "2", "3", "4", "5", "6"};
            HashMapProcessor hmp = new HashMapProcessor(arr);
            Thread t1 = new Thread(hmp, "t1");
            Thread t2 = new Thread(hmp, "t2");
            Thread t3 = new Thread(hmp, "t3");
            long start = System.currentTimeMillis();
            //start all the threads
            t1.start();
            t2.start();
            t3.start();
            //wait for threads to finish
            t1.join();
            t2.join();
            t3.join();
            System.out.println("Time taken= " + (System.currentTimeMillis() - start));
            //check the shared variable value now
            System.out.println(Arrays.asList(hmp.getMap()));
        }
    
    }
    
    
    class HashMapProcessor implements Runnable {
    
        private String[] strArr = null;
    
        public HashMapProcessor(String[] m) {
            this.strArr = m;
        }
    
        public String[] getMap() {
            return strArr;
        }
    
        @Override
        public void run() {
            processArr(Thread.currentThread().getName());
        }
    
        private void processArr(String name) {
            for (int i = 0; i < strArr.length; i++) {
                //process data and append thread name
                processSomething(i);
                addThreadName(i, name);
            }
        }
    
        private void addThreadName(int i, String name) {
            strArr[i] = strArr[i] + ":" + name;
        }
    
        private void processSomething(int index) {
            // processing some job
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }

输出：

[1:t1, 2:t1:t2:t3, 3:t1:t2:t3, 4:t2:t3, 5:t1:t3, 6:t2:t1:t3]

字符串数组值因为共享数据而没有同步而被损坏。 以下是我们如何更改 addThreadName() 方法以使我们的程序线程安全。

private Object lock = new Object();
    private void addThreadName(int i, String name) {
        synchronized(lock){
        strArr[i] = strArr[i] +":"+name;
        }
    }

改变后的输出：

[1:t1:t2:t3, 2:t1:t3:t2, 3:t1:t3:t2, 4:t2:t3:t1, 5:t2:t3:t1, 6:t1:t2:t3]

[ConcurrentHashMap]: https://www.journaldev.com/122/java-concurrenthashmap-example-iterator
[https_www.journaldev.com_1058_deadlock-in-java-example]: https://www.journaldev.com/1058/deadlock-in-java-example]
[Link 1]: https://www.journaldev.com/797/what-is-java-string-pool