Java线程之synchronized

翻译：https://www.journaldev.com/1061/thread-safety-in-java



我们知道线程安全在Java中是一个非常重要的主题，当多个线程操作共享数据时，如果没有任何控制，将会产生数据不一致的问题。数据不一致的重要原因是，当更新一个变量的值时，是分三步完成的，第一获取变量值，第二对变量值进行更新，第三将修改后的变量值刷新到内存。

下面我们用一个简单程序来验证一下这个问题，多线程去更新共享数据：

package com.lkf.mulithread;
public class ThreadSafety {
    public static void main(String[] args) throws InterruptedException {
        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "线程1");
        t1.start();
        Thread t2 = new Thread(pt, "线程2");
        t2.start();
        //wait for threads to finish processing
        t1.join();
        t2.join();
        System.out.println("执行次数：" + pt.getCount());
    }
    static class ProcessingThread implements Runnable {
        private int count;
        @Override
        public void run() {
            for (int i = 1; i < 5; i++) {
                processSomething(i);
                count++;
            }
        }
        private void processSomething(int i) {
            // processing some job
            try {
                Thread.sleep(i * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public int getCount() {
            return this.count;
        }
    }
}

当多次执行之后，我们会发现，最终的结果是6或7或8，而不是我们的预期结果8，出现这种情况的原因就在于count++

保证线程安全

针对多线程环境下，线程安全问题，有以下几种方法来解决：

1.关键字Synchronization是使用最简单应用最广泛的确保线程安全的方式

2.使用原子包装类，位于java.util.concurrent.atomic包下，比如：AutomicInteger

3.使用锁，位于java.util.concurrent.locks包下

4.使用线程安全集合类，比如：ConcurrentHashMap

5.使用volatile关键字保证线程每次直接从内存中读取变量值，而不是从工作内存中读取

Synchronized

• synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性.
• synchronized有两种使用方式，一种是锁定方法，另一种是锁定代码块
• 普通同步方法，锁的是当前实例对象，静态同步方法，锁的是当前类，因此最好的方法是，只锁定需要同步的代码块
• synchronized(this)锁定是当前对象，因为使用synchronized来保证线程安全具有一定的性能成本，因此建议在必要的时候使用

下面是推荐的保证线程安全的使用方式

    //虚拟对象
    private Object mutex=new Object();
    ...
    //using synchronized block to read, increment and update count value synchronously
    synchronized (mutex) {
            count++;
    }

事例分析

下面我们一起分析一些保证线程安全的一些事例：

事例1

public class MyObject {
  // 锁定对象的监视器
  public synchronized void doSomething() {
    // ...
  }
}
// Hackers code
MyObject myObject = new MyObject();
synchronized (myObject) {
  while (true) {
    // 无限期循环
    Thread.sleep(Integer.MAX_VALUE);
  }
}

注意，同步代码试图锁定myObject实例，一旦它获得了锁，它就不会释放它导致doSomething()方法阻塞等待锁，这会导致系统陷入死锁并导致Denial of Service (DoS)

事例2

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();

注意，锁对象是公共的，通过更改它的引用，我们可以在多个线程中执行同步块并行。这种方法是可行的，如果是私有锁对象，可以通过setter方法来修改它的引用

事例3

package com.lkf.mulithread;
import java.util.Arrays;
public class SyncronizedMethod {
    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()));
    }
    static 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();
            }
        }
    }
}

输出结果：

Time taken= 15015
[我是1号:线程t1:线程t2:线程t3,
我是2号:线程t1:线程t2:线程t3,
我是3号:线程t1:线程t2:线程t3,
我是4号:线程t1,
我是5号:线程t2,
我是6号:线程t3:线程t2]

可以看到每个线程中数组数据不完整，是因为共享数据没有同步造成的

下面我们修改一下代码，来保证线程安全：

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

输出结果：

Time taken= 15015
[我是1号:线程t1:线程t2:线程t3,
我是2号:线程t1:线程t3:线程t2,
我是3号:线程t1:线程t3:线程t2,
我是4号:线程t1:线程t3:线程t2,
我是5号:线程t3:线程t2:线程t1,
我是6号:线程t3:线程t1:线程t2]