Java多线程(3) 线程的同步-上

概述

最近比较忙，线程的同步其实在12月上旬就完成的差不多了，但是一直因为项目的关系，所以没有办法及时的发出来，在新的一年里会努力的扩充自己的技术栈。在多线程的实际应用中，多个线程经常需要共享对同一数据的存取，这样的情况就称为竞争条件。假设i的值为0，A线程执行i=i+1，B线程执行i=i+2，那么最后的值有可能不是3，而是1或者2。因为A读取i后尚未完成计算写入，B线程马上读取i，此时i的值还是0，当A线程执行后i的值变为1，但是B线程已经不会再重新读取i了，在B线程完成计算写入i的值就是2了，当然，如果A线程后完成计算，值也有可能就是1了。所以，多线程中同步是一个很重要的问题(我更喜欢叫控制线程)。

没有同步存取的线程

先看一个没有进行同步存取的例子，在这个例子当中共有2个子线程，1个负责累加，对value从加1至加1000，1个负责累减，对value从减1000至减1，那么接下来就开始贴代码。

package com.utopia.controls;

public class NoControl {
private static int value;

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 对value赋初值
value = 0;
System.out.println(value);
// 累加线程
Thread threadAdd = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 1; i <= 1000; i++) {
value += i;
}
}
});
// 累减线程
Thread threadSub = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 1000; i > 0; i--) {
value -= i;
}
}
});
// 同时运行俩个线程
threadAdd.start();
threadSub.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(value);
}

}

从理论上来讲，最后输出的结果应该是0，但是在实际运行中，虽然有时候结果也是0，但是大部分结果并不是0，如果把10000调至100000，那么结果出现不是0的概率将会更大。

其中一个结果截图：



如果使用多线程，那么出现这种情况我们必然是无法容忍的，所以就有了锁对象。

锁对象

其实，锁对象的概念是很好理解的。在上面我们分析过，出现存取不同步的原因是，Java语言中一条代码：i+=1;在翻译成机器码运行时会变成：读取i;完成加法;写到i的内存中;一共三条指令（在实际中，可能要比三条还多），A线程读取i进行计算加法时，B线程可能将减法的计算结果保存到i中，但是A线程再次保存就会将B线程的值进行覆盖，举个例子：

value = 0;

A: value += 10;

B: value -= 10;

1.A 读取value是0

2.B 读取value是0

3.B 计算得数是 -10 A计算得数是10

4.B 保存value是-10

5.A保存value是10

虽然理论上value的值是0，但最后结果value就是10

如果，我们可以加个锁，在A线程对value执行代码时，不允许B线程去执行，那么就不会出现这种情况了。对锁的使用一般分为3步：

1.对锁进行实例化

2.对线程进行加锁

3.对线程进行解锁

代码如图所示：

package com.utopia.controls;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Control {
private static int value;
// 对锁进行实例化
private static Lock valueLock = new ReentrantLock();

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 对value赋初值
value = 0;
System.out.println(value);
// 累加线程
Thread threadAdd = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 1; i <= 10000; i++) {
// 对累加线程上锁
valueLock.lock();
value += i;
// 对累加线程解锁
valueLock.unlock();
}
}
});
// 累减线程
Thread threadSub = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 10000; i > 0; i--) {
// 对累减线程上锁
valueLock.lock();
value -= i;
// 对累减线程去锁
valueLock.unlock();
}
}
});
// 同时运行俩个线程
threadAdd.start();
threadSub.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(value);
}

}

在进行线程同步后，可以发现结果永远都是0，如图：



锁是可重入的，线程可以重复的获得已经持有的锁，锁保持一个持有计数来跟踪lock方法的嵌套调用。例如：线程A在调用lock后持有锁，线程B在线程A调用unlock释放之前如果调用lock会发生阻塞，但是如果线程A再次调用lock方法则不会发生阻塞，但是线程A必须要执行2次unlock才可以释放锁。