理解——线程

1.线程

几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能有多个顺序执行流，每个顺序执行流就是一个线程。

1.1 线程与进程

当一个程序进入内存运行，即变成一个进程。进程是出于运行中的程序，并且具有一定独立功能，进程是系统进行资源分配和调度的一个独立单位。

进程特征：

• 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间
• 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合
• 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会影响。（并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得宏观上具有多个进程同时执行的效果）

线程时进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不再拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源，因此编程更加方便；但必须更加小心，我们必须确保线程不会妨碍同一进程里的其他线程。

 

线程是独立运行的，它并不知道进程中是否还有其他线程存在。线程的执行时抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另外一个线程可以运行。

一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。线程的调度和管理由进程本身负责完成，而不是操作系统。

 

简而言之：一个程序运行后至少有一个进程，一个进程里可以包含多个线程，但至少要包含一个线程。

 

1.2 多线程的优势

线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性：多个线程将共享同一个进程虚拟空间。线程共享的环境包括：进程代码段、进程的公有数据等。利用这些共享的数据，线程很容易实现相互之间的通信。

总结，使用多线程编程包含以下几个优点：

• 进程之间不能共享内存，但线程之间共享内存很容易
• 系统创建进程需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程效率高
• java语言内置多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了java的多线程编程

2. 线程的创建和启动

所有线程对象都必须是Thread类或其子类的实例。每条线程的作用是完成一定的任务，实际上就是执行一段程序流。Java用run()方法来封装这样一段程序流。在java中要想实现多线程，有两种手段，一种是继承Thread类，另外一种是实现Runable接口。

2.1 继承Thread类

//通过继承Thread类来创建线程类
public class FirstThread extends Thread
{
	private int i ;
	//重写run方法，run方法的方法体就是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			//当线程类继承Thread类时，可以直接调用getName()方法来返回当前线程的名。
			//如果想获取当前线程，直接使用this即可
			//Thread对象的getName返回当前该线程的名字
			System.out.println(getName() +  " " + i);
		}
	}
	
    public static void main(String[] args) 
    {
        for (int i = 0; i < 100;  i++)
        {
			//调用Thread的currentThread方法获取当前线程
			System.out.println(Thread.currentThread().getName() +  " " + i);
			if (i == 20)
			{
				//创建、并启动第一条线程
				new FirstThread().start();
				//创建、并启动第二条线程
				new FirstThread().start();
			}
        }
    }
}

 执行后查看输出结果，可以发现两条线程输出的i变量不连续，所以这两条线程不能共享数据。

• 注意：使用继承Thread类的方法来创建线程类，多条线程之间无法共享线程类的实例变量。

2.2 实现Runnable接口创建线程类

 

//通过实现Runnable接口来创建线程类
public class SecondThread implements Runnable
{
	private int i ;
	//run方法同样是线程执行体
	public void run()
	{
		for ( ; i < 100 ; i++ )
		{
			//当线程类实现Runnable接口时，
			//如果想获取当前线程，只能用Thread.currentThread()方法。
			System.out.println(Thread.currentThread().getName() + "  " + i);
		}
	}
	
    public static void main(String[] args) 
    {
        for (int i = 0; i < 100;  i++)
        {
			System.out.println(Thread.currentThread().getName() + "  " + i);
			if (i == 20)
			{
				SecondThread st = new SecondThread();
				//通过new Thread(target , name)方法创建新线程
				new Thread(st , "新线程1").start();
				new Thread(st , "新线程2").start();
			}
        }
    }
}

 

实现Runnable接口的实例只是作为Thread的Target来创建Thread对象，该Thread对象才是真正的线程对象。

从执行结果可以看出，采用实现Runnable接口的方式来创建的多条线程可以共享线程类的实例属性。

• 这是因为在这种情况下，程序所创建的Runnable对象只是线程的target，而多条线程可以共享同一个target，所以多条线程可以共享一个线程类（实际上应该是线程的target类）的实例属性。

 实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

• 注意：启动线程使用start方法，而不是run方法！永远不要调用线程对象的run方法！调用start方法来启动线程，系统会把该run方法当成线程执行体来处理。但如果直接调用线程对象的run方法，则run方法立即就会被执行，而且在run方法返回之前，其他线程无法并发执行——也就是说系统把线程对象当成了一个普通对象，而run方法也是一个普通方法，而不是线程执行体。

3. 控制线程

    3.1 join线程

Thread提供了让一个线程等待另一个线程完成的方法：join()方法。当在某个程序执行流中调用其他线程的join方法时，调用线程将被阻塞，直到被join方法加入的join线程完成为止。

public class JoinThread extends Thread
{
	//提供一个有参数的构造器，用于设置该线程的名字
	public JoinThread(String name)
	{
		super(name);
	}
	//重写run方法，定义线程执行体
	public void run()
	{
		for (int i = 0; i < 10 ; i++ )
		{
			System.out.println(getName() + "  " + i);
		}
	}
    public static void main(String[] args) throws Exception
    {
		//启动子线程
		new JoinThread("新线程").start();
		for (int i = 0; i < 10 ; i++ )
		{
			if (i == 5)
			{
				JoinThread jt = new JoinThread("被Join的线程");
				jt.start();
				//main线程调用了jt线程的join方法，main线程
				//必须等jt执行结束才会向下执行
				jt.join(); 
			}
			System.out.println(Thread.currentThread().getName() + "  " + i);
		}
    }
}

 "被Join的线程"被join到主线程中，则当i==5时，主线程被阻塞，此时只有“新线程”和 "被Join的线程"是并发执行的了。

     3.2 后台线程

有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又被称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程。
后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。
调用Thread对象setDaemon(true)方法可将指定线程设置成后台线程。

public class DaemonThread extends Thread
{
	//定义后台线程的线程执行体与普通线程没有任何区别
	public void run()
	{
		for (int i = 0; i < 1000 ; i++ )
		{
			System.out.println(getName() + "  " + i);
		}
	}

    public static void main(String[] args) 
    {
        DaemonThread t = new DaemonThread();
		//将此线程设置成后台线程
		t.setDaemon(true);
		//启动后台线程
		t.start();
		for (int i = 0 ; i < 10 ; i++ )
		{
			System.out.println(Thread.currentThread().getName()
				+ "  " + i);
		}
		//-----－程序执行到此处，前台线程（main线程）结束------
		//后台线程也应该随之结束
    }
}

 

注意：前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。
前台线程死亡后，JVM会通知后台线程死亡，但从它接受指令，到它做出响应，需要一定时间。而且要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是说setDaemon(true)必须在start()方法之前调用。

 3.3 线程睡眠：sleep

如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep方法。
当当前线程调用sleep方法进入阻塞状态后，在其sleep时间段内，该线程不会获得执行的机会，即使系统中没有其他可以运行的线程，处于sleep中的线程也不会运行，因此sleep方法常用来暂停程序的执行。

public class TestSleep
{
    public static void main(String[] args) throws Exception
    {
		for (int i = 0; i < 10 ; i++ )
		{
			System.out.println("当前时间: " + new Date());
			//调用sleep方法让当前线程暂停1s。
			Thread.sleep(1000);
		}
    }
}

 

上面的代码使得主线程每停止1s后再执行。

3.4 线程让步：yield

yield方法也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当前某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

实际上：当某个线程调用了yield方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程才会获得执行的机会。

public class TestYield extends Thread
{
	public TestYield()
	{
	}
	public TestYield(String name)
	{
		super(name);
	}
	//定义run方法作为线程执行体
	public void run()
	{
		for (int i = 0; i < 50 ; i++ )
		{
			System.out.println(getName() + "  " + i);
			//当i等于20时，使用yield方法让当前线程让步
			if (i == 20)
			{
				Thread.yield();
			}
		}
	}
    public static void main(String[] args) throws Exception
    {
		//启动两条并发线程
		TestYield ty1 = new TestYield("高级");
		//将ty1线程设置成最高优先级
		//ty1.setPriority(Thread.MAX_PRIORITY);
		ty1.start();
		TestYield ty2 = new TestYield("低级");
		//将ty1线程设置成最低优先级
		//ty2.setPriority(Thread.MIN_PRIORITY);
		ty2.start();	
    }
}

 

通常不要依靠yield方法来控制并发线程的执行。

3.5 改变线程优先级

每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。

public class PriorityTest extends Thread
{
	public PriorityTest(){}
	//定义一个有参数的构造器，用于创建线程时指定name
	public PriorityTest(String name)
	{
		super(name);
	}
	public void run()
	{
		for (int i = 0 ; i < 50 ; i++ )
		{
			System.out.println(getName() +  ",其优先级是："
				+ getPriority() + ",循环变量的值为:" + i);
		}
	}
	public static void main(String[] args) 
	{
		//改变主线程的优先级
		Thread.currentThread().setPriority(6);
		for (int i = 0 ; i < 30 ; i++ )
		{
			if (i == 10)
			{
				PriorityTest low  = new PriorityTest("低级");
				low.start();
				System.out.println("创建之初的优先级:" + low.getPriority());
				//设置该线程为最低优先级
				low.setPriority(Thread.MIN_PRIORITY);
			}
			if (i == 20)
			{
				PriorityTest high = new PriorityTest("高级");
				high.start();
				System.out.println("创建之初的优先级:" + high.getPriority());
				//设置该线程为最高优先级
				high.setPriority(Thread.MAX_PRIORITY);
			}
		}
	}
}

 

注：虽然java提供了10个级别的优先级（1-10），但这些优先级级别需要操作系统的支持。不幸的是，不同的操作系统优先级并不相同。所以我们应该尽量避免直接为线程指定优先级，而应该使用MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY三个静态常量来设置优先级，这样才可以保证程序具有最好的可移植性。

4. 线程同步

当使用多个线程来访问同一个数据时，非常容易出现线程安全问题，这是由于系统的线程调度具有一定的随机性。

    4.1 同步代码块

之所以出现线程安全问题，是因为run方法的方法体不具有同步安全性。为了解决这个问题，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。同步代码块语法如下：

synchronized(obj){
      ...
      //此处的代码就是同步代码块
}

上面语法格式中的obj就是同步监视器，上面代码的含义是：线程开始执行同步代码块之前，必须获得对同步监视器的锁定。任何时刻只能有一条线程可以获得对同步监视器的锁定，当同步代码块执行结束后，该线程自然释放了对该同步监视器的锁定。

• 虽然java程序允许使用任何对象来作为同步监视器，但想一下同步监视器的目的：阻止两条线程对同一个共享资源进行并发访问。因此通常推荐使用可能被并发访问的共享资源充当同步监视器。

以取款为例：

实体Account：

public class Account
{
	//封装账户编号、账户余额两个属性
	private String accountNo;
	private double balance;
	public Account(){}
	//构造器
	public Account(String accountNo , double balance)
	{
		this.accountNo = accountNo;
		this.balance = balance;
	}
	public void setAccountNo(String accountNo)
	{
		this.accountNo = accountNo;
	}
	public String getAccountNo()
	{
		 return this.accountNo;
	}

	public void setBalance(double balance)
	{
		 this.balance = balance;
	}
	public double getBalance()
	{
		 return this.balance;
	}


	//下面两个方法根据accountNo来计算Account的hashCode和判断equals
	public int hashCode()
	{
		return accountNo.hashCode();
	}
	public boolean equals(Object obj)
	{
		if (obj != null 
			&& obj.getClass() == Account.class)
		{
			Account target = (Account)obj;
			return target.getAccountNo().equals(accountNo);
		}
		return false;
	}
}

 取款线程类DrawThread：

public class DrawThread extends Thread
{
	//模拟用户账户
	private Account account;
	//当前取钱线程所希望取的钱数
	private double drawAmount;

	public DrawThread(String name , Account account , 
		double drawAmount)
	{
		super(name);
		this.account = account;
		this.drawAmount = drawAmount;
	}

	//当多条线程修改同一个共享数据时，将涉及到数据安全问题。
	public void run()
	{
		//使用account作为同步监视器，任何线程进入下面同步代码块之前，
		//必须先获得对account账户的锁定——其他线程无法获得锁，也就无法修改它
		//这种做法符合：加锁-－>修改完成-->释放锁 逻辑
		synchronized (account)
		{
			//账户余额大于取钱数目
			if (account.getBalance() >= drawAmount)
			{
				//吐出钞票
				System.out.println(getName() + 
					"取钱成功！吐出钞票:" + drawAmount);
				try
				{
					Thread.sleep(1);			
				}
				catch (InterruptedException ex)
				{
					ex.printStackTrace();
				}
				//修改余额
				account.setBalance(account.getBalance() - drawAmount);
				System.out.println("\t余额为: " + account.getBalance());
			}
			else
			{
				System.out.println(getName() + "取钱失败！余额不足！");
			}
		}
	}
}

 

测试类TestDraw：

public class TestDraw
{
    public static void main(String[] args) 
    {
		//创建一个账户
		Account acct = new Account("1234567" , 1000);
		//模拟两个线程对同一个账户取钱
		new DrawThread("甲" , acct , 800).start();
		new DrawThread("乙" , acct , 800).start();
    }
}

 

对上面的程序，我们就考虑使用用户账户（Account）作为同步监视器。

    4.2 同步方法

与同步代码块对应的，java的多线程安全支持还提供了同步方法，同步方法就是使用synchronized关键字来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无须显示指定同步监视器，同步方法的同步监视器是this，也就是该对象本身。

通过使用同步方法可以非常方便地将某类变成线程安全的类，线程安全的类的特征如下：

• 该类的对象可以被多个线程安全的访问
• 每个线程调用该类的任意方法之后都将得到正确的结果
• 每个线程调用该类的任意方法之后，该对象状态依然保持合理状态

上面取钱的例子中Account就是一个线程不安全的类，当两个线程同时修改Account的balance属性时，程序就出现了异常，现在将Account类变成一个线程安全的类，只需要把修改balance的方法修饰成同步方法即可。

Account：

public class Account
{
	private String accountNo;
	private double balance;


	public Account(){}

	public Account(String accountNo , double balance)
	{
		this.accountNo = accountNo;
		this.balance = balance;
	}

	public void setAccountNo(String accountNo)
	{
		this.accountNo = accountNo;
	}
	public String getAccountNo()
	{
		 return this.accountNo;
	}

	public double getBalance()
	{
		 return this.balance;
	}
	public synchronized void draw(double drawAmount)
	{
		//账户余额大于取钱数目
		if (balance >= drawAmount)
		{
			//吐出钞票
			System.out.println(Thread.currentThread().getName() + 
				"取钱成功！吐出钞票:" + drawAmount);
			try
			{
				Thread.sleep(1);			
			}
			catch (InterruptedException ex)
			{
				ex.printStackTrace();
			}
			//修改余额
			balance -= drawAmount;
			System.out.println("\t余额为: " + balance);
		}
		else
		{
			System.out.println(Thread.currentThread().getName() +
				"取钱失败！余额不足！");
		}
	}

	public int hashCode()
	{
		return accountNo.hashCode();
	}
	public boolean equals(Object obj)
	{
		if (obj != null && obj.getClass() == Account.class)
		{
			Account target = (Account)obj;
			return target.getAccountNo().equals(accountNo);
		}
		return false;
	}
}

 

上面程序将代表取钱的方法draw()使用了synchronized修改为同步方法了，同步方法的同步监视器是this，就当前对象（Account的实例），因此对于同一个Account而言，任意时刻只能有一条线程获得对Account对象的锁定，然后进入draw方法进行取钱，这样既可保证多条线程并发取钱时的线程安全了。此时，取钱的线程类DrawThread，只需要调用Account对象的draw方法既可。

DrawThread：

public class DrawThread extends Thread
{
	//模拟用户账户
	private Account account;
	//当前取钱线程所希望取的钱数
	private double drawAmount;

	public DrawThread(String name , Account account , 
		double drawAmount)
	{
		super(name);
		this.account = account;
		this.drawAmount = drawAmount;
	}

	//当多条线程修改同一个共享数据时，将涉及到数据安全问题。
	public void run()
	{
		account.draw(drawAmount);
	}
}

 

可变类的线程安全是以降低程序的运行效率作为代价的，为了减少线程安全所带来的负面影响，可以采用如下策略：

• 不要对线程安全类的所有方法都进行同步，只对那些会改变竞争资源（共享资源）的方法进行同步。例如Account的balance属性
• 如果可变类有两种运行环境：单线程、多线程环境，则应该为该可变类提供两种版本：线程不安全版本和线程安全版本。在单线程环境中使用线程不安全版本以保证性能，在多线程环境中使用线程安全版本。

    4.3 同步锁

java提供了另外一种线程同步的机制：它通过显示定义同步锁对象来实现同步，在这种机制下，同步锁应该使用Lock对象充当。
Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。不过，某些锁可能允许对共享资源并发访问，如ReadWriteLock（读写锁）。在实现线程安全的控制中，通常喜欢使用ReentrantLock（可重入锁）。

通过Lock对象我们可以将Account修改为如下形式，它依然是线程安全的：

Account：

public class Account
{
	//定义锁对象
	private final ReentrantLock lock = new ReentrantLock();
	private String accountNo;
	private double balance;


	public Account(){}

	public Account(String accountNo , double balance)
	{
		this.accountNo = accountNo;
		this.balance = balance;
	}

	public void setAccountNo(String accountNo)
	{
		this.accountNo = accountNo;
	}
	public String getAccountNo()
	{
		 return this.accountNo;
	}

	public double getBalance()
	{
		 return this.balance;
	}
	public void draw(double drawAmount)
	{
		lock.lock();
		try
		{
			//账户余额大于取钱数目
			if (balance >= drawAmount)
			{
				//吐出钞票
				System.out.println(Thread.currentThread().getName() + 
					"取钱成功！吐出钞票:" + drawAmount);
				try
				{
					Thread.sleep(1);			
				}
				catch (InterruptedException ex)
				{
					ex.printStackTrace();
				}
				//修改余额
				balance -= drawAmount;
				System.out.println("\t余额为: " + balance);
			}
			else
			{
				System.out.println(Thread.currentThread().getName() +
					"取钱失败！余额不足！");
			}			
		}
		finally
		{
			lock.unlock();
		}
	}

	public int hashCode()
	{
		return accountNo.hashCode();
	}
	public boolean equals(Object obj)
	{
		if (obj != null && obj.getClass() == Account.class)
		{
			Account target = (Account)obj;
			return target.getAccountNo().equals(accountNo);
		}
		return false;
	}
}

• ReentrantLock锁具有重入性，也就是说线程可以对它已经加锁的ReentrantLock锁再次加锁，ReentrantLock对象会维持一个计算器来追踪lock方法的嵌套调用，线程在每次调用lock()加锁后，必须显示调用unlock()来释放锁，所以一段被锁保护的代码可以调用另一个被相同锁保护的方法。

    4.4 死锁

当两个线程相互等待对方释放同步监视器时就会发生死锁，JVM没有检测，也没用采用措施来处理死锁情况，所以多线程编程时应该采取措施避免死锁的出现。一旦出现死锁，整个程序既不会发生任何异常，也不会给任何提示，只是所有线程处于阻塞状态，无法继续。死锁是很容易发生的，尤其在系统中出现多个同步监视器的情况下。

 

class A
{
    public synchronized void foo( B b )
	{
		System.out.println("当前线程名: " + 
			Thread.currentThread().getName() + " 进入了A实例的foo方法" );
		try
		{
			Thread.sleep(200);
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + 
		Thread.currentThread().getName() + " 企图调用B实例的last方法");
		b.last();
	}

	public synchronized void last()
	{
		System.out.println("进入了A类的last方法内部");
	}
}

class B
{
	public synchronized void bar( A a )
	{
		System.out.println("当前线程名: "
			+ Thread.currentThread().getName() + " 进入了B实例的bar方法" );
		try
		{
			Thread.sleep(200);
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " 
		+ Thread.currentThread().getName() + " 企图调用A实例的last方法");
		a.last();
	}

	public synchronized void last()
	{
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable
{
	A a = new A();
	B b = new B();

	public void init()
	{
		Thread.currentThread().setName("主线程");
		//调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}
	public void run()
	{
		Thread.currentThread().setName("副线程");
		//调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}
	public static void main(String[] args)
	{
		DeadLock dl = new DeadLock();
		//以dl为target启动新线程
		new Thread(dl).start();
		//执行init方法作为新线程
		dl.init();
	}
}

 上述程序中，主线程调用A对象的同步方法foo()时对A进行加锁，sleep过后，副线程得到执行调用B对象的同步方法bar()，sleep过后，主线程继续执行。此时，主线程需要访问B对象的last()方法，由于此时B对象被副线程加锁了，无法访问，而副线程由于同样的原因也无法访问A对象的last()方法。这样，两个线程都在等待对方先释放锁，程序就“僵住”了，无法执行下去，也不会报任何异常。

 5 线程通信

    5.1 线程的协调运行

可以借助Object类提供的wait()、notify()、notifyAll()三个方法。这三个方法必须由同步监视器对象来调用，可以分为两种情况：

• 对于同步方法，因为同步监视器就是this,所以可以在同步方法中直接调用这三个方法
• 对于同步代码块，同步监视器是synchronized后括号里的对象，所以必须使用该对象调用这三个方法

关于这三个方法的解释：

• wait():调用wait()方法的当前线程会释放对该同步监视器的锁定，直到其他线程调用该同步监视器的notify()或notifyAll()方法来唤醒该线程
• notify():唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会随机选择唤醒其中一个线程。只有当前线程放弃对该同步监视器的锁定后（使用wait()方法），才可以执行被唤醒的线程
• notifyAll():唤醒在此同步监视器上等待的所有线程

以一个取款和存款的线程为例，存款后立即取款，不允许多次存款或多次取款。

Account：

public class Account
{
	private String accountNo;
	private double balance;
	//标识账户中是否已有存款的旗标
	private boolean flag = false;

	public Account(){}

	public Account(String accountNo , double balance)
	{
		this.accountNo = accountNo;
		this.balance = balance;
	}

	public void setAccountNo(String accountNo)
	{
		this.accountNo = accountNo;
	}
	public String getAccountNo()
	{
		 return this.accountNo;
	}

	public double getBalance()
	{
		 return this.balance;
	}
	public synchronized void draw(double drawAmount)
	{
		try
		{
			//如果flag为假，表明账户中还没有人存钱进去，则取钱方法阻塞
			if (!flag)
			{
				wait();
			}
			else
			{
				//执行取钱
				System.out.println(Thread.currentThread().getName() + 
					" 取钱:" +  drawAmount);
				balance -= drawAmount;
				System.out.println("账户余额为：" + balance);
				//将标识账户是否已有存款的旗标设为false。
				flag = false;
				//唤醒其他线程
				notifyAll();
			}
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}
	public synchronized void deposit(double depositAmount)
	{
		try
		{
			//如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
			if (flag)
			{
				wait();
			}
			else
			{
				//执行存款
				System.out.println(Thread.currentThread().getName() + 
					" 存款:" +  depositAmount);
				balance += depositAmount;
				System.out.println("账户余额为：" + balance);
				//将表示账户是否已有存款的旗标设为true
				flag = true;
				//唤醒其他线程
				notifyAll();
			}
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
	}

	public int hashCode()
	{
		return accountNo.hashCode();
	}
	public boolean equals(Object obj)
	{
		if (obj != null && obj.getClass() == Account.class)
		{
			Account target = (Account)obj;
			return target.getAccountNo().equals(accountNo);
		}
		return false;
	}
}

 

存款线程DepositThread：

public class DepositThread extends Thread
{
	//模拟用户账户
	private Account account;
	//当前取钱线程所希望存款的钱数
	private double depositAmount;

	public DepositThread(String name , Account account , 
		double depositAmount)
	{
		super(name);
		this.account = account;
		this.depositAmount = depositAmount;
	}

	//重复100次执行存款操作
	public void run()
	{
		for (int i = 0 ; i < 100 ; i++ )
		{
			account.deposit(depositAmount);
		}		
	}
}

 

取款线程DrawThread：

public class DrawThread extends Thread
{
	//模拟用户账户
	private Account account;
	//当前取钱线程所希望取的钱数
	private double drawAmount;

	public DrawThread(String name , Account account , 
		double drawAmount)
	{
		super(name);
		this.account = account;
		this.drawAmount = drawAmount;
	}

	//重复100次执行取钱操作
	public void run()
	{
		for (int i = 0 ; i < 100 ; i++ )
		{
			account.draw(drawAmount);
		}
	}
}

 

测试类TestDraw：

public class TestDraw
{
	public static void main(String[] args) 
	{
		//创建一个账户
		Account acct = new Account("1234567" , 0);
		new DrawThread("取钱者" , acct , 800).start();
		new DepositThread("存款者甲" , acct , 800).start();
		new DepositThread("存款者乙" , acct , 800).start();
		new DepositThread("存款者丙" , acct , 800).start();
	}
}

 

程序最后会被阻塞，这是由于一共有三个存款者而只有一个取款者，300次存款操作只有100次取款操作，存款线程需要取款线程释放同步监视器锁，故而存款操作无法继续下去，所以最后被阻塞。注意，阻塞并不是死锁。

    5.2 使用条件变量控制协调

如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器对象，也就不能使用wait、notify、notifyAll方法来协调进程的运行。
当使用Lock对象来保证同步时，java提供了一个Condition类来保持协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。

Lock替代了同步方法或同步代码块，Condition替代了同步监视器的功能。实例实质上被绑定到一个Lock对象上，要获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法即可。Condition类提供了三个方法：

• await():同wait()
• signal:同notify()
• signalAll:同notifyAll()

Account：

public class Account
{
	//显示定义Lock对象
	private final Lock lock = new ReentrantLock();
	//获得指定Lock对象对应的条件变量
	private final Condition cond  = lock.newCondition(); 

	private String accountNo;
	private double balance;

	//标识账户中是否已经存款的旗标
	private boolean flag = false;

	public Account(){}

	public Account(String accountNo , double balance)
	{
		this.accountNo = accountNo;
		this.balance = balance;
	}

	public void setAccountNo(String accountNo)
	{
		this.accountNo = accountNo;
	}
	public String getAccountNo()
	{
		 return this.accountNo;
	}

	public double getBalance()
	{
		 return this.balance;
	}
	public void draw(double drawAmount)
	{
		//加锁
		lock.lock();
		try
		{
			//如果账户中还没有存入存款，该线程等待
			if (!flag)
			{
				cond.await();
			}
			else
			{
				//执行取钱操作
				System.out.println(Thread.currentThread().getName() + 
					" 取钱:" +  drawAmount);
				balance -= drawAmount;
				System.out.println("账户余额为：" + balance);
				//将标识是否成功存入存款的旗标设为false
				flag = false;
				//唤醒该Lock对象对应的其他线程
				cond.signalAll();
			}
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
		//使用finally块来确保释放锁
		finally
		{
			lock.unlock();
		}
	}
	public void deposit(double depositAmount)
	{
		lock.lock();
		try
		{
			//如果账户中已经存入了存款，该线程等待
			if(flag)
			{
				cond.await();				
			}
			else
			{
				//执行存款操作
				System.out.println(Thread.currentThread().getName() + 
					" 存款:" +  depositAmount);
				balance += depositAmount;
				System.out.println("账户余额为：" + balance);
				//将标识是否成功存入存款的旗标设为true
				flag = true;
				//唤醒该Lock对象对应的其他线程
				cond.signalAll();
			}
		}
		catch (InterruptedException ex)
		{
			ex.printStackTrace();
		}
		//使用finally块来确保释放锁
		finally
		{
			lock.unlock();
		}
	}

	public int hashCode()
	{
		return accountNo.hashCode();
	}
	public boolean equals(Object obj)
	{
		if (obj != null && obj.getClass() == Account.class)
		{
			Account target = (Account)obj;
			return target.getAccountNo().equals(accountNo);
		}
		return false;
	}
}

 执行效果和前一个方法一样。

    5.3 使用管道流

管道流有3种形式：PipedInputStream和PipedOutputStream，PipedReader和PipedWriter以及Pipe.SinkChannel和Pipe.SourceChannel，它们分别是管道字节流、管道字符流和新IO的管道Channel。

class ReaderThread extends Thread
{
	private PipedReader pr;
	//用于包装管道流的BufferReader对象
	private BufferedReader br;
	public ReaderThread(){}
	public ReaderThread(PipedReader pr)
	{
		this.pr = pr;
		this.br = new BufferedReader(pr);
	}
	public void run()
	{
		String buf = null;
		try
		{
			//逐行读取管道输入流中的内容
			while ((buf = br.readLine()) != null)
			{
				System.out.println(buf);
			}
		}
		catch (IOException ex)
		{
			ex.printStackTrace();
		}
		//使用finally块来关闭输入流
		finally
		{
			try
			{
				if (br != null)
				{
					br.close();
				}
			}
			catch (IOException ex)
			{
				ex.printStackTrace();
			}
		}
	}
}
class WriterThread extends Thread
{
	String[] books = new String[]
	{
		"Struts2权威指南",
		"ROR敏捷开发指南",
		"基于J2EE的Ajax宝典",
		"轻量级J2EE企业应用指南"
	};
	private PipedWriter pw;
	public WriterThread(){}
	public WriterThread(PipedWriter pw)
	{
		this.pw = pw;
	}
	public void run()
	{
		try
		{
			//循环100次，向管道输出流中写入100个字符串
			for (int i = 0; i < 100 ; i++)
			{
				pw.write(books[i % 4] + "\n");
			}
		}
		catch (IOException ex)
		{
			ex.printStackTrace();
		}
		//使用finally块来关闭管道输出流
		finally
		{
			try
			{
				if (pw != null)
				{
					pw.close();
				}
			}
			catch (IOException ex)
			{
				ex.printStackTrace();
			}
		}
	}
}

public class PipedCommunicationTest
{
	public static void main(String[] args)
	{
		PipedWriter pw = null;
		PipedReader pr = null;
		try
		{
			//分别创建两个独立的管道输出流、输入流
			pw = new PipedWriter();
			pr = new PipedReader();
			//连接管道输出流、出入流
			pw.connect(pr);

			//将连接好的管道流分别传入2个线程，
			//就可以让两个线程通过管道流进行通信
			new WriterThread(pw).start();
			new ReaderThread(pr).start();
		}
		catch (IOException ex)
		{
			ex.printStackTrace();
		}
	}
}

 

通常没有必要使用管道流来控制两个线程之间的通信，因为两个线程属于同一个进程，它们可以非常方便的共享数据，这种方式才是线程之间进行信息交换的最好方式，而不是使用管道流。

6 ThreadLocal类

线程局部变量（ThreadLocal）的功能非常简单，就是为每一个使用该变量的线都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。

class Account
{
	/*定义一个ThreadLocal类型的变量，该变量将是一个线程局部变量
	  每个线程都会保留该变量的一个副本*/
	private ThreadLocal<String> name = 
		new ThreadLocal<String>();
	//定义一个初始化name属性的构造器
	public Account(String name)
	{
		this.name.set(name);
		//下面代码看到输出“初始名”
		System.out.println("------" + this.name.get());
	}
	//定义了name属性的setter和getter方法
	public String getName()
	{
		return name.get();
	}
	public void setName(String str)
	{
		this.name.set(str);
	}
}
class MyTest extends Thread
{
	//定义一个Account属性
	private Account account;
	public MyTest(Account account, String name)
	{
		super(name);
		this.account = account;
	}
	public void run()
	{
		//循环10次
		for (int i = 0 ; i < 10 ; i++)
		{
			//当i == 6时输出将账户名替换成当前线程名
			if (i == 6)
			{
				account.setName(getName());
			}
			//输出同一个账户的账户名和循环变量
			System.out.println(account.getName()
				+ " 账户的i值：" + i);
		}
	}
}
public class ThreadLocalTest
{
	public static void main(String[] args) 
	{
		//启动两条线程，两条线程共享同一个Account
		Account at = new Account("初始名");
		/*
		虽然两条线程共享同一个账户，即只有一个账户名
		但由于账户名是ThreadLocal类型的，所以两条线程将
		导致有同一个Account，但有两个账户名的副本，每条线程
		都完全拥有各自的账户名副本，所以从i == 6之后，将看到两条
		线程访问同一个账户时看到不同的账户名。
		*/
		new MyTest(at , "线程甲").start();
		new MyTest(at , "线程乙").start();
	}
}

 

同步机制是为了同步多个线程对相同资源的并发访问，是多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上避免了多个线程之间的共享资源（变量），也就不需要对多个线程进行同步了。

7 包装线程不安全的集合

java集合ArrayList、LinkedList、HashSet、TreeSet、HashMap等都是线程不安全的，也就是有可能当多个线程向这些集合中放入一个元素时，可能会破坏这些集合数据的完整性。
如果有多条线程可能访问以上这些集合，我们可以使用Collections提供的静态方法来把这些集合包装成线程安全的集合。

如：

//使用Collections的synchronizedMap方法将一个普通的HashMap包装成线程安全的类
HashMap hashMap = Collections.synchronizedMap(new HashMap());