Java中处理线程同步

引自：http://blog.csdn.net/aaa1117a8w5s6d/article/details/8295527和http://m.blog.csdn.net/blog/undoner/12849661

静态变量：线程非安全。

静态变量即类变量，位于方法区，为所有对象共享，共享一份内存，一旦静态变量被修改，其他对象均对修改可见，故线程非安全。

实例变量：单例模式（只有一个对象实例存在）线程非安全，非单例线程安全。

实例变量为对象实例私有，在虚拟机的堆中分配，若在系统中只存在一个此对象的实例，在多线程环境下，“犹如”静态变量那样，被某个线程修改后，其他线程对修改均可见，故线程非安全；如果每个线程执行都是在不同的对象中，那对象与对象之间的实例变量的修改将互不影响，故线程安全。

局部变量：线程安全。

每个线程执行时将会把局部变量放在各自栈帧的工作内存中，线程间不共享，故不存在线程安全问题。

静态变量线程安全问题模拟：

----------------------------------------------------------------------------------

/**
* 线程安全问题模拟执行
* ------------------------------
* 线程1 | 线程2
* ------------------------------
* static_i = 4; | 等待
* static_i = 10; | 等待
* 等待 | static_i = 4;
* static_i * 2; | 等待
* -----------------------------
* */
public class Test implements Runnable
{
private static int static_i;//静态变量
public void run()
{
static_i = 4;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取static_i 的值:" + static_i);
static_i = 10;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取static_i*3的值:" + static_i * 2);
}
public static void main(String[] args)
{
Test t = new Test();
//启动尽量多的线程才能很容易的模拟问题
for (int i = 0; i < 3000; i++)
{
//t可以换成new Test(),保证每个线程都在不同的对象中执行，结果一样
new Thread(t, "线程" + i).start();
}
}
}

根据代码注释中模拟的情况，当线程1执行了static_i = 4; static_i = 10; 后，线程2获得执行权，static_i = 4; 然后当线程1获得执行权执行static_i * 2; 必然输出结果4*2=8，按照这个模拟，我们可能会在控制台看到输出为8的结果。

写道

[线程27]获取static_i 的值:4
[线程22]获取static_i*2的值:20
[线程28]获取static_i 的值:4
[线程23]获取static_i*2的值:8
[线程29]获取static_i 的值:4
[线程30]获取static_i 的值:4
[线程31]获取static_i 的值:4
[线程24]获取static_i*2的值:20

看红色标注的部分，确实出现了我们的预想，同样也证明了我们的结论。

实例变量线程安全问题模拟：

----------------------------------------------------------------------------------

public class Test implements Runnable
{
private int instance_i;//实例变量
public void run()
{
instance_i = 4;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取instance_i 的值:" + instance_i);
instance_i = 10;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取instance_i*3的值:" + instance_i * 2);
}
public static void main(String[] args)
{
Test t = new Test();
//启动尽量多的线程才能很容易的模拟问题
for (int i = 0; i < 3000; i++)
{
//每个线程对在对象t中运行，模拟单例情况
new Thread(t, "线程" + i).start();
}
}
}

按照本文开头的分析，犹如静态变量那样，每个线程都在修改同一个对象的实例变量，肯定会出现线程安全问题。

写道

[线程66]获取instance_i 的值:10
[线程33]获取instance_i*2的值:20
[线程67]获取instance_i 的值:4
[线程34]获取instance_i*2的值:8
[线程35]获取instance_i*2的值:20
[线程68]获取instance_i 的值:4

看红色字体，可知单例情况下，实例变量线程非安全。

将new Thread(t, "线程" + i).start();改成new Thread(new Test(), "线程" + i).start();模拟非单例情况，会发现不存在线程安全问题。

局部变量线程安全问题模拟：

----------------------------------------------------------------------------------

public class Test implements Runnable
{
public void run()
{
int local_i = 4;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取local_i 的值:" + local_i);
local_i = 10;
System.out.println("[" + Thread.currentThread().getName()
+ "]获取local_i*2的值:" + local_i * 2);
}
public static void main(String[] args)
{
Test t = new Test();
//启动尽量多的线程才能很容易的模拟问题
for (int i = 0; i < 3000; i++)
{
//每个线程对在对象t中运行，模拟单例情况
new Thread(t, "线程" + i).start();
}
}
}

控制台没有出现异常数据。

**************************************************************

为什么要线程同步？

　　说到线程同步，大部分情况下，我们是在针对“单对象多线程”的情况进行讨论，一般会将其分成两部分，一部分是关于“共享变量”，一部分关于“执行步骤”。

如何控制线程同步

　　既然线程同步有上述问题，那么我们应该如何去解决呢？针对不同原因造成的同步问题，我们可以采取不同的策略。

1.控制共享变量

　　我们可以采取3种方式来控制共享变量。

　　（1）将“单对象多线程”修改成“多对象多线程”　　

　　上文提及，同步问题一般发生在“单对象多线程”的场景中，那么最简单的处理方式就是将运行模型修改成“多对象多线程”的样子，针对上面示例中的同步问题，修改后的代码如下：

 1 private static void sharedVaribleTest2() throws InterruptedException

 2 {

 3     Thread thread1 = new Thread(new MyRunner());

 4     Thread thread2 = new Thread(new MyRunner());

 5     thread1.setDaemon(true);

 6     thread2.setDaemon(true);

 7     thread1.start();

 8     thread2.start();

 9     thread1.join();

10     thread2.join();

11 }

　　我们可以看到，上述代码中两个线程使用了两个不同的Runnable实例，它们在运行过程中，就不会去访问同一个全局变量。

　　（2）将“全局变量”降级为“局部变量”

　　既然是共享变量造成的问题，那么我们可以将共享变量改为“不共享”，即将其修改为局部变量。这样也可以解决问题，同样针对上面的示例，这种解决方式的代码如下：

 1 class MyRunner2 implements Runnable

 2 {

 3     public void run()

 4     {

 5         System.out.println(Thread.currentThread().getName() + " Start.");

 6         int sum = 0;

 7         for (int i = 1; i <= 100; i++)

 8         {

 9             sum += i;

10         }

11         try {

12             Thread.sleep(500);

13         } catch (InterruptedException e) {

14             e.printStackTrace();

15         }

16         System.out.println(Thread.currentThread().getName() + " --- The value of sum is " + sum);

17         System.out.println(Thread.currentThread().getName() + " End.");

18     }

19 }

20

21

22 private static void sharedVaribleTest3() throws InterruptedException

23 {

24     MyRunner2 runner = new MyRunner2();

25     Thread thread1 = new Thread(runner);

26     Thread thread2 = new Thread(runner);

27     thread1.setDaemon(true);

28     thread2.setDaemon(true);

29     thread1.start();

30     thread2.start();

31     thread1.join();

32     thread2.join();

33 }

　　我们可以看出，sum变量已经由全局变量变为run方法内部的局部变量了。

　　（3）使用ThreadLocal机制

　　ThreadLocal是JDK引入的一种机制，它用于解决线程间共享变量，使用ThreadLocal声明的变量，即使在线程中属于全局变量，针对每个线程来讲，这个变量也是独立的。

　　我们可以用这种方式来改造上面的代码，如下所示：

 1 class MyRunner3 implements Runnable

 2 {

 3     public ThreadLocal<Integer> tl = new ThreadLocal<Integer>();

 4

 5     public void run()

 6     {

 7         System.out.println(Thread.currentThread().getName() + " Start.");

 8         for (int i = 0; i <= 100; i++)

 9         {

10             if (tl.get() == null)

11             {

12                 tl.set(new Integer(0));

13             }

14             int sum = ((Integer)tl.get()).intValue();

15             sum+= i;

16             tl.set(new Integer(sum));

17             try {

18                 Thread.sleep(10);

19             } catch (InterruptedException e) {

20                 e.printStackTrace();

21             }

22         }

23

24         System.out.println(Thread.currentThread().getName() + " --- The value of sum is " + ((Integer)tl.get()).intValue());

25         System.out.println(Thread.currentThread().getName() + " End.");

26     }

27 }

28

29

30 private static void sharedVaribleTest4() throws InterruptedException

31 {

32     MyRunner3 runner = new MyRunner3();

33     Thread thread1 = new Thread(runner);

34     Thread thread2 = new Thread(runner);

35     thread1.setDaemon(true);

36     thread2.setDaemon(true);

37     thread1.start();

38     thread2.start();

39     thread1.join();

40     thread2.join();

41 }

　　综上三种方案，第一种方案会降低多线程执行的效率，因此，我们推荐使用第二种或者第三种方案。

2.控制执行步骤

　　说到执行步骤，我们可以使用synchronized关键字来解决它。

 1 class MySyncRunner implements Runnable

 2 {

 3     public void run() {

 4         synchronized(this)

 5         {

 6             System.out.println(Thread.currentThread().getName() + " Start.");

 7             for(int i = 1; i <= 5; i++)

 8             {

 9                 System.out.println(Thread.currentThread().getName() + " Running step " + i);

10                 try

11                 {

12                     Thread.sleep(50);

13                 }

14                 catch(InterruptedException ex)

15                 {

16                     ex.printStackTrace();

17                 }

18             }

19             System.out.println(Thread.currentThread().getName() + " End.");

20         }

21     }

22 }

23

24

25 private static void syncTest2() throws InterruptedException

26 {

27     MySyncRunner runner = new MySyncRunner();

28     Thread thread1 = new Thread(runner);

29     Thread thread2 = new Thread(runner);

30     thread1.setDaemon(true);

31     thread2.setDaemon(true);

32     thread1.start();

33     thread2.start();

34     thread1.join();

35     thread2.join();

36 }

　　在线程同步的话题上，synchronized是一个非常重要的关键字。它的原理和数据库中事务锁的原理类似。我们在使用过程中，应该尽量缩减synchronized覆盖的范围，原因有二：1）被它覆盖的范围是串行的，效率低；2）容易产生死锁。我们来看下面的示例：