多条线程在操作同一份数据的时候，一般需要程序去控制好变量。在多条线程同时运行的前提下控制变量，涉及到线程通信及变量保护等。
本博文主要总结：①线程是如何通信 ②如何保护线程变量
1、Java里的线程通信
在多线程的第二小节已经总结过：控制多条线程访问方法，可以通过synchronized关键字对方法上锁，保证每次只有一条线程能够调用该方法。但让程序交替执行方法，那得给线程上锁，且通过线程间的通信完成变量之间的共享及操作。
Java里面线程间通信对程序员是透明的，通过线程操作变量具体步骤如下:
上图为线程间共享数据时的通信图，在Java程序内发生线程通信的主要表现在第③步骤。这一步主要通过wait、notify 和 notifyall 三个方法完成，线程间的数据共享以及通信;
举个没什么实际意义的例子：现在有两条线程，一条线程对k变量进行累加，一条线程对k进行累减，交替执行5次。跟第二篇总结的例子基本一致，但第二篇的例子没有对数据进行操作，单纯地对内容进行加减。
package com.scl.thread; public class ThreadCommunicateReview
{
public static void main(String[] args)
{
int k = 10;
// 把calculator作为内部类的操作成员，操作共享变量K
final Calculator calculator = new Calculator(k);
new Thread(new Runnable()
{
@Override
public void run()
{
SleepHelper.sleep(100);
// 进行四轮调换
for (int i = 0; i < 4; i++)
{
calculator.addNum();
}
} }, "add").start(); new Thread(new Runnable()
{ @Override
public void run()
{
SleepHelper.sleep(100);
// 进行四轮调换
for (int i = 0; i < 4; i++)
{
calculator.subNum();
}
}
}, "sub").start();
}
} // 建立计算类，把相关计算内容整合到同一个类里面进行管理
class Calculator
{
// 让操作变量属于同一个类，在外部使用
private int k = 0;
private volatile boolean isAdd = true; public Calculator(int value)
{
this.k = value;
} public synchronized void addNum()
{
while (!isAdd)
{
try
{
// 不是进行“加”操作时，线程进行等待，释放对象锁
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 循环五次进行递增
for (int i = 0; i < 5; i++)
{
System.out.println(Thread.currentThread().getName() + " " + ++k);
}
// 执行完递减操作后，把标识位标识为递减，通知其他线程竞争对象锁
isAdd = false;
notify();
} public synchronized void subNum()
{
while (isAdd)
{
try
{
// 进行“加”操作时，线程进行等待
wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 循环五次进行递减
for (int i = 0; i < 5; i++)
{
System.out.println(Thread.currentThread().getName() + " " + --k);
}
// 执行完递减操作后，把标识位标识为增加，通知其他线程竞争对象锁
isAdd = true;
notify();
}
}
view code
package com.scl.thread; public class SleepHelper
{
public static void sleep(long sleepTime)
{
try
{
Thread.sleep(sleepTime);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
SleepHelper
输出结果如下：
应该注意的是：
1. wait和notify方法都是在Object里面集成过来的，但是两个方法都是被定义成final类型，没法通过子类的继承对这两个方法进行修改。
2. wait和notify方法必须放在Synchronized定义的代码块内，因为这两个方法必须得到对象锁。
当对象调用wait方法时，会释放掉对象的锁，然后进行等待。notify同样会把当前锁对象释放，唤醒等待的线程对对象进行锁竞争。
线程变量操作需要注意的是：
1. 共享的线程变量必须是外部变量/全局变量。synchronized修饰的方法内部不需要任何volatile变量约束，也不必要对这些局部变量约束
2. 使变量被多个线程操作具体方法有两个
①使用两条线程，线程内部有一个变量引用，通过变量应用共同操作同一个业务类
②把业务类定义被final约束，在匿名内部类Runnable内调用业务类的相关方法完成操作（如上述例子）
3. 根据面向对象的编程思想，对线程内的业务操作最好整合到一个类里面。
2、Java线程变量保护
上面的代码涉及了部分线程变量共享以及线程通信，但是怎么使用Java去保护每条线程独立的变量呢。即让线程A操作自己的变量，线程B操作自己的变量，两条线程的变量互不干涉？这个问题跟JDBC里面的事务很相似。因为事务必须是独立的，每个不同的事务需要在不同的连接上完成，且互不干涉。
线程之间互不干涉，那就把变量设置成线程的局部变量，让每条线程自己去完成任务就可以了。开始的时候，笔者也是如此想的。后来发现，如果要执行这种线程变量的传递，是件非常麻烦的事情！比如：有一个共享计算器(Calculator)，可以提供给其他人进行加减操作，要求通过日志类(LogService)把相关的线程操作记录，同时记录每条线程操作的时间及线程调用方法。为避免重复，还需要在线程内生成相关的UUID，标注每个不同的线程。
根据上述的要求及面向对象的设计模式，程序必须设计三个类：
①计算器类Calculator，负责集成加减法的业务逻辑，每个线程内的加减法必须上锁
②日志类LogService，记录线程运行时间，记录线程UUID等。
③线程类，负责生成相关的UUID随机数，因模拟加减两个操作，需要分开两条线程：一个为AddRunable，另一个命名为SubRunable
大致如下：
线程类记录线程相关信息，与线程运行业务分离
package com.scl.thread.threadlocal; import java.util.UUID; class AddRunable implements Runnable
{
private Calculator calculator;
private String myRandomId; public String getMyRandomId()
{
return myRandomId;
} public void setMyRandomId(String myRandomId)
{
this.myRandomId = myRandomId;
} public AddRunable(Calculator c)
{
this.calculator = c;
} @Override
public void run()
{
calculator.addNum(1000);
} private String CreateRandomId()
{
myRandomId = UUID.randomUUID().toString();
return myRandomId;
} } class SubRunable implements Runnable
{
private Calculator calculator;
private String myRandomId; public String getMyRandomId()
{
return myRandomId;
} public void setMyRandomId(String myRandomId)
{
this.myRandomId = myRandomId;
} public SubRunable(Calculator c)
{
this.calculator = c;
} @Override
public void run()
{
calculator.subNum(1000);
} private String CreateRandomId()
{
myRandomId = UUID.randomUUID().toString();
return myRandomId;
} }
两个Runnable
Calculator的两方法设置为自增及自减
package com.scl.thread.threadlocal; public class Calculator
{ public void addNum(int value)
{
LogTimeChecker.star();
for (int i = 0; i < 10000000; i++)
{
value++;
}
System.out.println(value);
LogTimeChecker.end();
} public void subNum(int value)
{
for (int i = 0; i < 100; i++)
{
value--;
}
}
}
Calculator
使用LogTimeChecker记录线程运行时间及调用内容
package com.scl.thread.threadlocal; public class LogTimeChecker
{
static long beginMills;
static long endMills; public static void star()
{
beginMills = System.currentTimeMillis();
} public static void end()
{
String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
endMills = System.currentTimeMillis();
System.out.println( methodName + " cost:" + (endMills - beginMills));
}
}
日志类LogTimeChecker
客户端测试代码
package com.scl.thread.threadlocal; import org.junit.Test; public class TestLog4Thread
{
@Test
public void TestLog() throws InterruptedException
{
Calculator c = new Calculator(); Thread t1 = new Thread(new AddRunable(c));
t1.start();
Thread t2 = new Thread(new AddRunable(c));
t2.start();
t1.join();
t2.join();
}
}
客户端代码
在没完成本段代码之前，必须说明下目前这段代码的问题。日志类代码跟计算业务类代码强关联，如果有一百个方法需要加日志，每次都要在类的方法内添加begin，和end两个方法，耦合度太高...此处不进行修改，详细修改内容可参见另一篇博文：动态代理模式
先撇开日志记录方法的问题，要把线程变量贯穿三层，最好就是这在日志类里面能够使用类似Thread.currentThread( )方法获取当前线程的类，然后使用类的getMyRandomId方法获取到在线程产生的UUID。可是JDK并没有通过Thread.currentThread( )去获取自定义线程内的类对象。
那么程序可能需要在每一层传输Runnable对象。
① 把参数传到日志类对象内，那么日志类的方法可能变成这样：
public static void start(Runnable r)
{
AddRunable run = (AddRunable)r;
run.getMyRandomId();
beginMills = System.currentTimeMillis();
}
这里还要获取出对象到底是AddRunable还是SubRunable,然后转换. ② 要在计算器对象内，把Runnable对象进行传递
public void addNum(int value,Runnable r)
{ LogTimeChecker.start(r);
for (int i = 0; i < 10000000; i++)
{
value++;
}
System.out.println(value);
LogTimeChecker.end();
}
③ 修改AddRunable里面的run方法
public void run()
{
calculator.addNum(1000, this);
}
我的天... 想想都觉得麻烦,而且还要去判断Runnable对象，在日志类内进行转换!这时候需要使用ThreadLocal，在一层内写代码，在三层内共享数据，且每个线程内的数据独立。简单地说，就是实现在日志类内通过Thread.currentThread( )的思想，获得每条线程自己的内容，不在层间传递。
修改如下：
package com.scl.thread.threadlocal; public class LogTimeChecker
{
static long beginMills;
static long endMills; public static void start()
{
beginMills = System.currentTimeMillis();
} public static void end()
{
String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
endMills = System.currentTimeMillis();
// 通过静态类获取ThreadLocal对象内容TestLog4Thread.threadLocal.get()
System.out.println(TestLog4Thread.threadLocal.get() + " " + methodName + " cost:" + (endMills - beginMills));
}
}
日志类对象代码
package com.scl.thread.threadlocal; public class Calculator
{
// 自增次数
public void addNum(int value)
{ LogTimeChecker.start();
for (int i = 0; i < 10000000; i++)
{
value++;
}
System.out.println(value);
LogTimeChecker.end();
} // 递减循环
public void subNum(int value)
{
LogTimeChecker.start();
for (int i = 0; i < 100; i++)
{
value--;
}
LogTimeChecker.end();
}
}
计算器对象代码
package com.scl.thread.threadlocal; import java.util.UUID; class AddRunable implements Runnable
{
private Calculator calculator;
private String myRandomId; public String getMyRandomId()
{
return myRandomId;
} public void setMyRandomId(String myRandomId)
{
this.myRandomId = myRandomId;
} public AddRunable(Calculator c)
{
this.calculator = c;
} @Override
public void run()
{
this.setThreadLocal();
calculator.addNum(1000);
} private String CreateRandomId()
{
myRandomId = UUID.randomUUID().toString();
return myRandomId;
} private void setThreadLocal()
{
// 获取当前线程下ThreadLocal的内容，如果为空，设置相关的值
if (TestLog4Thread.threadLocal.get() == null)
{
TestLog4Thread.threadLocal.set(CreateRandomId());
}
}
} class SubRunable implements Runnable
{
private Calculator calculator;
private String myRandomId; public String getMyRandomId()
{
return myRandomId;
} public void setMyRandomId(String myRandomId)
{
this.myRandomId = myRandomId;
} public SubRunable(Calculator c)
{
this.calculator = c;
} @Override
public void run()
{
this.setThreadLocal();
calculator.subNum(1000);
} private String CreateRandomId()
{
myRandomId = UUID.randomUUID().toString();
return myRandomId;
} private void setThreadLocal()
{
// 获取当前线程下ThreadLocal的内容，如果为空，设置相关的值
if (TestLog4Thread.threadLocal.get() == null)
{
TestLog4Thread.threadLocal.set(CreateRandomId());
}
}
}
Runnable类代码
package com.scl.thread.threadlocal; import org.junit.Test; public class TestLog4Thread
{
//在对象内定义threadLocal对象，并进行初始化
static ThreadLocal<String> threadLocal = new ThreadLocal<String>()
{
@Override
protected String initialValue()
{
return null;
}
}; @Test
public void TestLog() throws InterruptedException
{
Calculator c = new Calculator(); Thread t1 = new Thread(new AddRunable(c));
t1.start();
Thread t2 = new Thread(new SubRunable(c));
t2.start();
t1.join();
t2.join();
}
}
客户端测试代码
启动20条线程，测试如下：
以上就是使用ThreadLocal对线程的变量进行独立的操作。其实例子可以不使用ThreadLocal来贯穿三层代码，可以使用HashMap代替。但通过HashMap把线程和对应的变量存储，不但HashMap会变得很大，线程销毁的时候还要对HashMap里面的数据进行删除这样就显得比较麻烦。
关于ThreadLocal的源码解析可以查看以下链接 : http://www.iteye.com/topic/103804
最后总结下ThreadLocal的作用：
① 确保了层级间方法的独立，避免参数传递
② 确保线程间数据的独立，不进行数据同步
③ 提供了有效的变量回收机制，避免内存泄漏
以上为本人对线程通讯的总结，有错误的地方烦请指正。