Java之线程同步与安全（Thread Synchronize & Safe）

[color=green][size=medium][b]Java之线程同步与安全（Thread Synchronize & Safe）[/b][/size][/color]

[size=medium][b]一、问题背景[/b][/size]

Java语言提供了多线程的功能。
多线程创建于相同的Object，多线程间共享Object的变量或属性。
但是，当线程对共享的数据进行读写时，会导致数据的不一致（data inconsistency）。


[size=medium][b]二、线程同步情景分析[/b][/size]

数据不一致的原因是由数据操作的非原子性引起的。
即：更新任何属性或变量，非一步完成，而是需要三部：
1、读取现在的值。
2、进行必要的操作以得到要更新的值。
3、把更新的值写入到引用的变量或属性中。


来看一个简单的例子：
多个线程共享一个数据，并对其进行修改。

public class ThreadSafety {

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

        ProcessingThread pt = new ProcessingThread();
        Thread t1 = new Thread(pt, "t1");
        t1.start();
        Thread t2 = new Thread(pt, "t2");
        t2.start();
        //wait for threads to finish processing
        t1.join();
        t2.join();
        System.out.println("Processing count="+pt.getCount());
    }

}

class ProcessingThread implements Runnable{
    private int count;

    @Override
    public void run() {
        for(int i=1; i < 5; i++){
            processSomething(i);
        	count++;
        }
    }

    public int getCount() {
        return this.count;
    }

    private void processSomething(int i) {
        // processing some job
        try {
            Thread.sleep(i*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

上述循环中，使用两个线程对 count 变量的值进行增加，每个线程各增加四次。
最后 count 的值应该是 8。但是在实际的多次运行中，它的值在 6,7,8 之间。
发生这种情况，即使 count++ 看起来是单原子操作，实际不是。
从而导致数据不一致。


[size=medium][b]三、Java中保证线程同步的方法[/b][/size]

为了在多线程运行环境中确保数据的一致，Java提供了一些方法。
下面是主要的几种：

1、使用 synchronized 关键字（最广泛使用）

2、使用 java.util.concurrent.atomic 包下的原子操作包装类。
例如： AtomicInteger

3、使用 java.util.concurrent.locks 包下的锁类

4、使用 线程安全的集合类。
例如： ConcurrentHashMap

5、使用 volatile 关键字确保读的一致性。（不能确保写一致）
确保每个线程是从内存中读取值，而不是线程缓存中。


[b]三·一 使用 synchronized 关键字[/b]

JVM 可以确保被 synchronized 修饰的代码块每次只能被一个线程访问执行。
内部通过锁住一个对象或类来实现。

1、synchronized 可以在被锁定的资源或未被锁定的资源情况下工作。
但是，在任何线程执行 synchronized 代码块之前，
它需要首先获取这个对象的锁才可以执行。
而线程执行非 synchronized 代码块不需要获取对象的锁。
当然，线程在代码块执行完毕后，需要释放该锁。
这样其它处于等待状态的线程可以获取对象的锁以执行。

2、synchronized 的使用方式有两种：
1）用在类方法的声明上。使整个方法成为 synchronized 方法。
此时会锁定 Object （实例），如果是静态方法则锁类。
为了提高运行性能，请尽量少使用该策略。

2）单独使用。形成一个 synchronized 代码块。
只锁定方法中需要锁定的代码块。
此时，需要提供资源，以从该资源中取得锁。
资源可以是 ABC.class 或 类的一个属性。

synchronized(this) 会锁定当前整个实例，
即同时获取了当前实例的锁 + 实例所有属性的锁。
注意：为了提高执行性能，被锁的对象应该是最小范围的。
例如在一个类中有多个 synchronized 的代码块，其中
一块锁定了整个实例。则其它代码块则不能被其它线程执行。

3、synchronized 是以降低性能为代价的（本来可以并行执行，先只能串行执行）。
所以非必需，不要用。

4、synchronized 只在同一个 JVM 中是有效的。

5、synchronized 会造成[死锁]现象。
synchronized 代码块同时锁定多个对象。多个线程互相等待其它线程释放对象的锁。

6、synchronized 不能用于 构造方法 和 局部变量。

7、synchronized 锁定的实例，应该避免是 常量池 中的对象。
这些常量池中的对象可能被其它 synchronized 代码块引用。例如：String pool

8、synchronized 通常锁定一个虚设的 private 的类属性，对代码块进行锁定。
因为 private 的引用指向的实例始终是一个。不会变。


下面的改进使 count 属性线程安全的代码：

//dummy object variable for synchronization
private Object mutex=new Object();

//using synchronized block to read, increment and update count value synchronously
synchronized (mutex) {
    count++;
}

让我们看一些 synchronized 的例子，看看我们能学到什么：


例子一：

public class MyObject {

  // Locks on the object's monitor
  public synchronized void doSomething() { 
    // ...
  }
}

public class Hack{
    public static void main(String[] args){
        // Hackers code
        MyObject myObject = Factory.getMyObject();
        synchronized (myObject) {
          while (true) {
            // Indefinitely delay myObject
            Thread.sleep(Integer.MAX_VALUE); 
          }
        }
    }
}

如果能够拿到 MyObject 的实例，并且在锁定该实例无限长的时间。
其它代码则无法执行该实例的方法。尤其在单例模式中。


例子二：

更有甚者：

package com.gentleman.sychronized;

public class Hack {    
    public static void main(String[] args) throws Exception{
        new Thread(new R1()).start();
        Thread.sleep(1000);
        new Thread(new R2()).start();
        new Thread(new R3()).start();
    }
}

class MyObject {
    public void sayHello(){
        synchronized(MyObject.class){
            System.out.println("C: Hello, Word");
        }
    }
    public synchronized void sayHello2(){
        System.out.println("M: Hello, Word");
    }
}


class R1 implements Runnable{
    @Override
    public void run(){
        synchronized (MyObject.class) {
            System.out.println("Lock class instance!");
            while (true) {
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } 
            }
        }
    }
}


class R2 implements Runnable{
    @Override
    public void run() {
        MyObject myObject = new MyObject();
        myObject.sayHello();
    }
}

class R3 implements Runnable{
    @Override
    public void run() {
        MyObject myObject = new MyObject();
        myObject.sayHello2();
    }
}

输出结果：
Lock class instance!
M: Hello, Word

分析：
C: Hello, Word
这一句没有输出，因为 MyObject.class 对象被其它 Lock 锁定


根据结果可以看出：
要锁定的对象可以是类（class），也可以是类的实例（instance）。
但是类和类的实例在锁的问题上不相关，也没有权限上你大我小的隶属关系。


[url=http://stackoverflow.com/a/2056256/2893073][b]锁对象和锁类的区别？[/b][/url]

[b]synchronized(X.class)[/b]
使用 class类 所为锁定对象， 那是因为只有一个 class 类在 JVM 中被 classLoader 加载。
如果一个线程要执行该代码块，必须拥有 class 类的锁。
此时只能有一个线程在执行该代码块。

[b]synchronized(this)[/b]
使用类的实例为锁定对象。
如果一个线程要执行该代码块，只需拥有实例的锁即可。
此时可以有多个线程在执行该代码块。


例子三：

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 属性是 public 的。通过替换它指向引用的对象，多个线程就可以执行 synchronized 块的代码。
类似情况：private 的属性，但是有 public 的 set() 方法。


例子四：

static void myMethod() {
  synchronized(MyClass.class) {
    //code
  }
}

// 等价于：

static synchronized void myMethod() {
  //code
}

注意：没有 static 关键字，则不等价。

void myMethod() {
  synchronized(this) {
    //code
  }
}

// 等价于：

synchronized void myMethod() {
  //code
}

例子五：

import java.util.Arrays;

public class T {

    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;
    }

    @Override
    public void run() {        
        for(int i=0; i < strArr.length; i++){
            processSomething(i);            
            addThreadName( i,  Thread.currentThread().getName());
        }
    }

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

    private void processSomething(int index) {
        // processing some job
        try {
            Thread.sleep(index * 100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String[] getMap() {
        return strArr;
    }

}

输出：
Time taken= 1501
[1:t1, 2:t2, 3:t2:t3, 4:t1, 5:t1:t2, 6:t3:t2]


加上同步锁：

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

输出：
Time taken= 1502
[1:t1:t2:t3, 2:t2:t1:t3, 3:t1:t2:t3, 4:t1:t2:t3, 5:t2:t1:t3, 6:t1:t2:t3]


继续阅读：

[url=http://lixh1986.iteye.com/blog/2351294]使用 java.util.concurrent.lock.Lock 实现线程同步[/url]


-
转载请注明，
原文出处：http://lixh1986.iteye.com/blog/2351243


-
引用：

http://www.journaldev.com/1061/thread-safety-in-java