Java多线程学习

为了学习hadoop源代码作准备，今天复习了以下Java多线程内容，在此记录如下。

多线程程序程序

可以同时运行多个线程的程序叫做多线程程序,可以同时运行的线程的数量并不是由cpu数目确定的，操作系统根据一定 的调度算法给每个线程分配cpu时间片。多线程程序有广泛应用，例如网络上多线程下载，GUI变成中的事件响应等等。个人感觉那些比较耗时的任务和交互式任务，都需要使用多线程提高性能。 多线程有诸多优点，甚至很多问题只有采用多线程才能解决。网上有大量Java多线程的实例。

多线程的同步问题

在多个线程程序中，当有2个以上的线程对同一共享变了进行操作，就产生了同步问题。同步问题是多线程程序必须要解决的问题。在Java中解决同步问题的方法是加锁。加锁分为显示加锁和隐式加锁，显示加锁可以使用 Java5.0引入的ReentrantLock类。隐式加锁使用Java提供的synchronized关键字。

下面以银行账户为例讲解上述两种加锁的实现方法，加锁原理，首先构建一个银行，银行中有若干账户，开启多个线程，每个线程随机的从一个账户转账到另一个账户，正常情况下，银行的资金总额应该保持不变，因为只是账户间转账操作。

账户类Account

public class Account {
	private double money; // 账户资金
	public String name;   // 账户名称
	
	public Account(String name , double initMoney) {
		this.name = name;
		this.money = initMoney;
	}
	public double getMoney() {
		return money;
	}

	public void setMoney(double money) {
		this.money = money;
	}
	
	public String getAccountName() {
		return name;
	}
}

银行类Bank

/**
 *  银行类
 * @author hadoop
 *
 */
public class Bank{
	public ArrayList<Account> accountList = new ArrayList<Account>(); 
	public static final int NUMACCOUNT = 10;
	public static final double INITMONEY = 1000;
	
	public Bank(){
		for(int i = 0; i < NUMACCOUNT ; ++i) {
			Account account = new Account("account"+ Integer.toString(i), INITMONEY);
			accountList.add(account);
		}
	}
		
	public double sum() {
		double sum = 0;
		for(Account a: accountList) {
			sum += a.getMoney();
		}
		return sum;
	}
		
	public void transfer(Account from , Account to , double amount){
		
		try{
			
			System.out.print(from.getAccountName()+"还有"+from.getMoney());
			System.out.println(","+to.getAccountName()+"还有"+to.getMoney());
			while(from.getMoney() < amount){
				suffientCondition.wait();
			}
			from.setMoney(from.getMoney()-amount);
			Thread.sleep(10);  //### 模拟线程执行耗时操作到此被阻塞
			to.setMoney(to.getMoney()+amount);
			System.out.println("从账户  " + from.getAccountName()+" 转账 100 到 账户 " + to.getAccountName()
					+" ，   总账户余额为 "+sum());
			
		}catch(InterruptedException e){
			System.out.println("产生了中断异常");
			e.printStackTrace();
		}
		finally {
			bankLock.unlock();
		}
	}
}

转账操作类TranMoney ，实现 Runnable接口

class TranMoney implements Runnable{
	public static final double AMOUNT = 100;
	
	private Bank bank;
	public TranMoney(Bank bank){
		this.bank = bank;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		int from = (int)(bank.accountList.size()*Math.random());
		int to = 0;
		do{
			to = (int)(bank.accountList.size()*Math.random());
		}while(from == to);
		bank.transfer(bank.accountList.get(from),bank.accountList.get(to),AMOUNT); //###转账操作
	}
}

主类Main

public class Main {

	public static final int OP_NUM = 10;
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Bank bank = new Bank();
			System.out.println(bank.sum());
			for(int i = 0 ; i < OP_NUM ; ++i){
				TranMoney tranMoney = new TranMoney(bank);
				Thread t = new Thread(tranMoney);
				t.start();
				System.out.println("线程 "+ t.getName()+" 开始执行......");
			}
	}

}

在没有进行同步控制下，运行程序输出：

从账户  account6 转账 100 到 账户 account7 ，   总账户余额为 9200.0 从账户  account7 转账 100 到 账户 account5 ，   总账户余额为 9300.0 从账户  account8 转账 100 到 账户 account4 ，   总账户余额为 9200.0 从账户  account4 转账 100 到 账户 account0 ，   总账户余额为 9500.0 从账户  account6 转账 100 到 账户 account4 ，   总账户余额为 9600.0 从账户  account4 转账 100 到 账户 account7 ，   总账户余额为 9500.0

从上面输出可以看到，在没有进行同步控制下，银行账户的总余额很快出错，这是人们不可接受的。所以对于共享数据的访问，必须采用同步存取。

使用显示加锁法ReentryLock类

ReentryLock是一个一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 

此类的构造方法接受一个可选的公平 参数。当设置为 true 时，在多个线程的争用下，这些锁倾向于将访问权授予等待时间最长的线程。否则此锁将无法保证任何特定访问顺序。与采用默认设置（使用不公平锁）相比，使用公平锁的程序在许多线程访问时表现为很低的总体吞吐量（即速度很慢，常常极其慢），但是在获得锁和保证锁分配的均衡性时差异较小。不过要注意的是，公平锁不能保证线程调度的公平性。因此，使用公平锁的众多线程中的一员可能获得多倍的成功机会，这种情况发生在其他活动线程没有被处理并且目前并未持有锁时。还要注意的是，未定时的 tryLock 方法并没有使用公平设置。因为即使其他线程正在等待，只要该锁是可用的，此方法就可以获得成功。

建议总是 立即实践，使用 lock 块来调用 try，在之前/之后的构造中，最典型的代码如下：

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body 
     } finally {
       lock.unlock()
     }
   }
 }

熟悉了ReentryLock类的使用方法后，修改Bank类中的transfer方法，如下所示，即可实现线程安全操作

private Lock bankLock = new ReentrantLock(); // ### 获取可重入锁对象
private Condition suffientCondition = bankLock.newCondition();  //###  在该锁对象上，获取条件变量
public void transfer(Account from , Account to , double amount){
		bankLock.lock();
		try{
			//  ---------- 临界区开始----------
			System.out.print(from.getAccountName()+"还有"+from.getMoney());
			System.out.println(","+to.getAccountName()+"还有"+to.getMoney());
			while(from.getMoney() < amount){   // ###　账户余额小于转出金额，该线程需要等待
				suffientCondition.wait();
			}
			from.setMoney(from.getMoney()-amount);
			Thread.sleep(10);  //### 模拟线程执行耗时操作到此被阻塞
			to.setMoney(to.getMoney()+amount);
			System.out.println("从账户  " + from.getAccountName()+" 转账 100 到 账户 " + to.getAccountName()
					+" ，   总账户余额为 "+sum());
			// ---------- 临界区结束-----------
		}catch(InterruptedException e){
			System.out.println("产生了中断异常");
			e.printStackTrace();
		}
		finally {
			bankLock.unlock(); //#### 无论是否抛出异常，都必须释放锁
		}
	}

使用了上面的代码后，就实现了对银行账户的同步存取，获取可重入公平锁对象bankLock，然后在程序进入临界区代码前加锁，这样就保证了只有一个线程在执行临界区代码。

注意上面的代码中使用到了 条件变量，条件变量是Java多线程编程中又一重要概念。当线程在执行临界区代码时候，如果由于某些条件没有满足导致线程不能继续执行，例如上述问题中的：账户余额小于转出金额时候。当前线程就无法继续执行，必须等待其他线程转入足够的钱到该账户中。该线程才能继续执行。 这个时候就需要条件变量。一个ReentryLock锁对象可以有一个或者多个条件变量，在Lock接口中定义了获取条件变量的方法 newCondition（）。如果条件没有满足，就调用条件对象的await方法，当前线程就进入阻塞，释放锁。

使用隐式加锁法：synchronized关键字

Java从1.0开始，Java中的每个对象都有一个内部锁。如果一个方法使用Synchronized关键字，那么对象锁就会保护整个方法。

对于如下的同步方法

public Synchronized void method() {

         method body

}

等价于

public void method() {

       this.innerLock.lock();

       try{

                method body 

       }finally{

                this.innerLock.unlock();

       }

}

修改Bank类的方法，分别在sum方法和transfer方法前面添加 synchronized关键字，即可实现对该方法的加锁，注意这种加锁是对象锁，同一时刻只允许一个线程访问该对象

public synchronized double sum() {
		double sum = 0;
		for(Account a: accountList) {
			sum += a.getMoney();
		}
		return sum;
	}
			
	public synchronized void transfer(Account from , Account to , double amount){
		System.out.print(from.getAccountName()+"还有"+from.getMoney());
		System.out.println(","+to.getAccountName()+"还有"+to.getMoney());
		while(from.getMoney() < amount){
			suffientCondition.wait();
		}
		from.setMoney(from.getMoney()-amount);
		Thread.sleep(10);  //### 模拟线程执行耗时操作到此被阻塞
		to.setMoney(to.getMoney()+amount);
		System.out.println("从账户  " + from.getAccountName()+" 转账 100 到 账户 " + to.getAccountName()
					+" ，   总账户余额为 "+sum());
				
	}

Synchronized关键字不仅可以用在方法上，也可以用在语句块中。Synchronized的详细用法见下面博客，下面部分转载：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html

同步加锁的是对象，而不是代码，不是类。

因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。

 参考下面的代码：

class Foo extends Thread 
{ 
　private int val; 
　public Foo(int v) 
　{ 
　　val = v; 
　} 
　public synchronized void printVal(int v) 
　{ 
　　while(true) 
　　　System.out.println(v); 
　} 
　public void run() 
　{ 
　　printVal(val); 
　} 
}
class SyncTest 
{ 
　public static void main(String args[]) 
　{ 
　　Foo f1 = new Foo(1); 
　　f1.start(); 
　　Foo f2 = new Foo(3);
　　f2.start(); 
　} 
} 

　　运行SyncTest产生的输出是1和3交叉的。如果printVal是断面，你看到的输出只能是1或者只能是3而不能是两者同时出现。程序运行的结果证明两个线程都在并发的执行printVal方法，即使该方法是同步的并且由于是一个无限循环而没有终止。

类的同步：

要实现真正的断面，你必须同步一个全局对象或者对类进行同步。下面的代码给出了一个这样的范例。

class Foo extends Thread 
{ 
　private int val; 
　public Foo(int v) 
　{ 
　　val = v; 
　} 
　public void printVal(int v) 
　{ 
　　synchronized(Foo.class) { 
　　　while(true)
　　　　System.out.println(v); 
　　} 
　} 
　public void run() 
　{ 
　　printVal(val); 
　} 
} 

　　上面的类不再对个别的类实例同步而是对类进行同步。对于类Foo而言，它只有唯一的类定义，两个线程在相同的锁上同步，因此只有一个线程可以执行printVal方法。

　　这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。

面笔者给出一个参考实现，给出同步公共对象的两种通常方法：

　　1、

class Foo extends Thread 
{ 
　private int val;
　private static Object lock=new Object();
　public Foo(int v) 
　{ 
　　val = v; 
　} 
　public void printVal(int v) 
　{ 
　　synchronized(lock) { 
　　　while(true)
　　　　System.out.println(v); 
　　} 
　} 
　public void run() 
　{ 
　　printVal(val); 
　} 
}

　　上面的这个例子比原文给出的例子要好一些，因为原文中的加锁是针对类定义的，一个类只能有一个类定义，而同步的一般原理是应该尽量减小同步的粒度以到达更好的性能。笔者给出的范例的同步粒度比原文的要小。

　　2、

class Foo extends Thread 
{
　private String name;
　private String val;
　public Foo(String name,String v) 
　{ 
　　this.name=name;
　　val = v; 
　} 
　public void printVal() 
　{ 
　　synchronized(val) { 
　　　while(true) System.out.println(name+val); 
　　} 
　} 
　public void run() 
　{ 
　　printVal(); 
　} 
}
public class SyncMethodTest 
{ 
　public static void main(String args[]) 
　{ 
　　Foo f1 = new Foo("Foo 1:","printVal"); 
　　f1.start(); 
　　Foo f2 = new Foo("Foo 2:","printVal");
　　f2.start(); 
　} 
}

　　上面这个代码需要进行一些额外的说明，因为JVM有一种优化机制，因为String类型的对象是不可变的，因此当你使用""的形式引用字符串时，如果JVM发现内存已经有一个这样的对象，那么它就使用那个对象而不再生成一个新的String对象，这样是为了减小内存的使用。

　　上面的main方法其实等同于：

public static void main(String args[]) 
{
　String value="printVal";
　Foo f1 = new Foo("Foo 1:",value); 
　f1.start(); 
　Foo f2 = new Foo("Foo 2:",value);
　f2.start(); 
} 

总结：

1、synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.