线程的同步互斥与通信
互斥的问题在使用线程的时候是我们必须要注意的。
例如两个线程同时开启,由于业务规则,需要访问同一个对象,要取得该对象
中的数据进行修改。
这样多个线程对同一个数据进行操作的实例有很多,例如银行交易。我们的账户中原来
有2000元,在同一时间,我们刷卡200购物,然后有人给我们转账500元,我们的账户余额
应该是2000-200+500=2300元。
但是,在类似上述场景的时候,我们不对线程做任何的操作,这个时候我们的数据可能就会出错。
只要涉及到多个线程操作相同数据的时候就会出现线程安全的问题。这是我们编写多线程程序的
时候特别需要注意的问题。
接下来我们编写一个传统的涉及线程安全问题的程序样例。
我们开启两个线程,分别打印一个传入的数据,打印方式是一个一个字符的打印。
我们运行一下这程序:
发现除了完整打印大写和小写字符串之外,有些时候打印某个线程的字符时,转而打印其它线程的字符。
如果要求每一个线程在运行的时候,中途不被打断,我们就要实现线程的“原子性”。即是执行某个线程的时候,其它线程不能执行。
实现线程的“互斥性”,我们要给线程中需要独立执行的代码块或者方法加“线程锁”。
我们使用synchronized来给需要线程独立运行的代码来加锁。其中synchronized有一个参数,该参数要求
是一个线程公用的参数,该参数具有唯一性,只要该参数的引用没有被释放,其他使用到该参数的线程就不能进行。
因为我们所有的线程调用的都是同一个Outputer类,我们给该类一个参数,将该参数
作为线程锁的“钥匙”:
如果每一个线程自己new一个Outputer类,那我们刚刚的那个锁就失去作用了,因为每个线程的Outputer
类的key参数不是同一个了,这个时候我们将锁的参数改为该类本身:
当然,我们只是想在调用Outputer类的output方法的时候实现互斥,合适的操做是给output方法加锁:
如果我们频繁在加锁的方法里再加锁的话,很有可能会发生“死锁”的现象。
最后,如果有类是静态类,调用的加锁方法又是静态方法,该类的其它非静态方法要与其互斥的话,
非静态方法中的synchronized(this)要改成synchronized(类名.class)。
最后,献上传统互斥技术的总结图:
互斥的问题在使用线程的时候是我们必须要注意的。
例如两个线程同时开启,由于业务规则,需要访问同一个对象,要取得该对象
中的数据进行修改。
这样多个线程对同一个数据进行操作的实例有很多,例如银行交易。我们的账户中原来
有2000元,在同一时间,我们刷卡200购物,然后有人给我们转账500元,我们的账户余额
应该是2000-200+500=2300元。
但是,在类似上述场景的时候,我们不对线程做任何的操作,这个时候我们的数据可能就会出错。
只要涉及到多个线程操作相同数据的时候就会出现线程安全的问题。这是我们编写多线程程序的
时候特别需要注意的问题。
接下来我们编写一个传统的涉及线程安全问题的程序样例。
我们开启两个线程,分别打印一个传入的数据,打印方式是一个一个字符的打印。
package cn.edu.hpu.test;
public class TraditionalThreadSynchronized {
public static void main(String[] args) {
new TraditionalThreadSynchronized().init();
}
public void init(){
final Outputer outputer=new Outputer();
new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("ABCDEFGHIJKLNOPQRST");
}
}
}
).start();
new Thread(new Runnable(){
public void run() {
while(true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("abcdefghijklmnopqrst");
}
}
}
).start();
}
class Outputer{
public void output(String name){
int len=name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
我们运行一下这程序:
发现除了完整打印大写和小写字符串之外,有些时候打印某个线程的字符时,转而打印其它线程的字符。
如果要求每一个线程在运行的时候,中途不被打断,我们就要实现线程的“原子性”。即是执行某个线程的时候,其它线程不能执行。
实现线程的“互斥性”,我们要给线程中需要独立执行的代码块或者方法加“线程锁”。
我们使用synchronized来给需要线程独立运行的代码来加锁。其中synchronized有一个参数,该参数要求
是一个线程公用的参数,该参数具有唯一性,只要该参数的引用没有被释放,其他使用到该参数的线程就不能进行。
因为我们所有的线程调用的都是同一个Outputer类,我们给该类一个参数,将该参数
作为线程锁的“钥匙”:
class Outputer{
String key="lock";
public void output(String name){
int len=name.length();
synchronized(key){
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
如果每一个线程自己new一个Outputer类,那我们刚刚的那个锁就失去作用了,因为每个线程的Outputer
类的key参数不是同一个了,这个时候我们将锁的参数改为该类本身:
class Outputer{
public void output(String name){
int len=name.length();
synchronized(this){
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
当然,我们只是想在调用Outputer类的output方法的时候实现互斥,合适的操做是给output方法加锁:
class Outputer{
public synchronized void output(String name){
int len=name.length();
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println();
}
}
如果我们频繁在加锁的方法里再加锁的话,很有可能会发生“死锁”的现象。
最后,如果有类是静态类,调用的加锁方法又是静态方法,该类的其它非静态方法要与其互斥的话,
非静态方法中的synchronized(this)要改成synchronized(类名.class)。
最后,献上传统互斥技术的总结图:
转载请注明出处:http://blog.csdn.net/acmman/article/details/52763352