黑马程序员——Java基础——多线程（二）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、死锁

由于线程可以获取多个锁，比如在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁，这样就可能会出现同步嵌套的情况。当两个线程被阻塞，每个线程在等待另一个线程时会导致死锁。在开发中一定要避免出现死锁。

class DeadLock implements Runnable
{
	//定义一个线程运行的标记
	private boolean flag;
	DeadLock(boolean flag)
	{
		this.flag = flag;
	}
	//定义两个对象锁
	static Object locka = new Object();
	static Object lockb = new Object();

	//定义线程运行中的同步嵌套
	public void run()
	{
		if(flag)
		{
			synchronized(locka)
			{
				System.out.println(Thread.currentThread().getName()+"...if locka ");
				synchronized(lockb)
				{
					System.out.println(Thread.currentThread().getName()+"..if lockb");					
				}
			}
			
		}
		else
		{
			synchronized(lockb)
			{
				System.out.println(Thread.currentThread().getName()+"..else lockb");
				synchronized(locka)
				{
					System.out.println(Thread.currentThread().getName()+".....else locka");
				}
			}
		}
	}
}
class  DeadLockDemo
{
	public static void main(String[] args) 
	{
		//定义两个线程，在构造中传递不同的标记并运行
		Thread t1 = new Thread(new DeadLock(true));
		Thread t2 = new Thread(new DeadLock(false));
		t1.start();
		t2.start();
	}
}

二、线程间的通信

1.线程间的通信就是多个线程在操作同一个资源，但是操作的动作却不一样，比如多线程常见的生产者—消费者-仓库模式，实现存入仓库一个资源，接着取出一个。

//创建仓库资源
class Resource {
	private String name;
	private int count = 1;
	private boolean flag = false;
	//定义存和取资源的方法，因为属于多个线程共同操作的内容，所以要加同步
	public synchronized void setIn(String name) {
		//根据定义的标记判断仓库内是否有资源
		//没有就往仓库存放，存放结束后改变标记，唤醒等待的线程
		//有就线程等待取出结束
		while (flag)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		this.name = name + "--" + count++;
		System.out.println(Thread.currentThread().getName() + "...生产者.."
				+ this.name);
		flag = true;
		this.notifyAll();
	}
	public synchronized void takeOut() {
		//根据定义的标记判断仓库内是否有资源
		//有就从仓库取出，取出结束后改变标记，唤醒等待的线程
		//如果没有就线程等待存放结束
		while (!flag)
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		System.out.println(Thread.currentThread().getName() + "...消费者.."
				+ this.name);
		flag = false;
		this.notifyAll();
	}
}
//定义生产者，存放商品，循环十次方便查看结果
class Producer implements Runnable {
	private Resource res;

	Producer(Resource res) {
		this.res = res;
	}

	public void run() {
		for(int x = 0 ; x < 10 ; x++)
		{
			res.setIn("+商品+");
		}
	}
}
//定义消费者，取出商品
class Consumer implements Runnable {
	private Resource res;

	Consumer(Resource res) {
		this.res = res;
	}

	public void run() {
		for(int x = 0; x < 10; x++)
		{
			res.takeOut();
		}
	}
}

//创建线程分别进行存放和读取，并运行
public class ProducerConsumerDemo {
	public static void main(String[] args) {
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

2.线程状态及常用方法

1）线程状态

被创建：线程对象已经创建，还没有在其上调用start方法。

可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

运行状态：获取了CPU执行权，执行程序代码。

临时状态（阻塞）：有执行资格，但是没有执行权。

冻结状态：遇到sleep方法和wait方法时，失去执行资格和执行权，sleep方法时间到或者调用notify方法时，获得执行资格，变为临时状态。

消忙状态：线程执行完了或者因异常退出了run方法，该线程结束生命周期

2）常用方法

wait：将同步中的线程处于冻结状态。释放了CPU执行权，释放了锁。同时将线程对象存储到线程池中。

sleep：释放CPU执行权，不释放锁。

notify：唤醒线程池中某一个等待线程。

notifyAll：唤醒的是线程池中的所有线程。

3.JDK1.5的升级

JDK1.5 中直接将锁封装成对象，把同步Synchronized替换成显示的Lock操作。将Object中的wait，notify notifyAll，替换了Condition对象。该对象可以通过Lock锁进行获取，并支持多个相关的Condition对象，可以针对性的唤醒指定Condition对象的线程。生产者消费者代码也可以用下面的代码实现：

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

//创建仓库资源
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

	private Lock lock = new ReentrantLock();
	//创建两个Condition，控制生产者和消费者线程间的通信
	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();



	public void setIn(String name) throws InterruptedException
	{
		//获取锁
		lock.lock();
		try
		{
			//根据定义的标记判断仓库内是否有资源
			//没有就往仓库存放，存放结束后改变标记，唤醒消费者等待的线程
			//有就等待消费者线程取出结束
			while(flag)
				condition_pro.await();
			this.name = name+"--"+count++;

			System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
			flag = true;
			condition_con.signal();
		}
		//释放锁的动作一定要执行，所以使用finally
		finally
		{
			lock.unlock();
		}
	}
	public void takeOut() throws InterruptedException
	{
		//获取锁
		lock.lock();
		try
		{
			//根据定义的标记判断仓库内是否有资源
			//有就从仓库取出，取出结束后改变标记，唤醒生产者等待的线程
			//如果没有就等待生产者线程存放结束
			while(!flag)
				try {
					condition_con.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
			flag = false;
			condition_pro.signal();
		}
		//释放锁的动作一定要执行，所以使用finally
		finally
		{
			lock.unlock();
		}
		
	}
}
//定义生产者，存放商品，循环十次方便查看结果
class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		for(int x = 0 ;x < 10; x++)
		{
			try {
				res.setIn("+商品+");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
		}
	}
}
//定义消费者，取出商品
class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run() 
	{
		for(int x = 0 ;x < 10; x++)
		{
			try {
				res.takeOut();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
}

//创建线程分别进行存放和读取，并运行
public class ProducerConsumerDemo {
	public static void main(String[] args) {
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

三、多线程题目

1.下列程序的运行结果

		new Thread(new Runnable(){
			public void run()
			{
				System.out.println("接口线程...");
			}
		})
		{
			public void run()
			{
				System.out.println("类线程...");
			}
		}.start();

运行结果：

这个题目使用两个匿名内部类，在没指定的情况下，子类构造函数调用的都是父类无参的构造函数，所以传入实现Runnbale的子类对象没有作用。

2.创建3个线程依次打印ABC，并且循环10次

public class ABCThread {

	// 定义标记，控制打印顺序和打印次数
	static int count = 1;

	public static void main(String[] args) {

		// 创建同步代码块的锁
		Object obj = new Object();

		//因为只有简单的多线程运行代码，所以使用匿名内部类传递
		Thread A = new Thread(new Runnable() {
			@Override
			//复写run方法，判断标记，如果符合就等待，
			//如果不符合执行打印代码，并使标记加1，唤醒其他所有在等待的线程
			public void run() {
				while (count <= 30) {
					synchronized (obj) {
						if (count % 3 != 1)
							try {
								obj.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						else {
							System.out.println("A");
							count++;
							obj.notifyAll();
						}
					}

				}
			}
		});
		Thread B = new Thread(new Runnable() {
			@Override
			//复写run方法，判断标记，如果符合就等待，
			//如果不符合执行打印代码，并使标记加1，唤醒其他所有在等待的线程
			public void run() {
				while (count <= 30) {
					synchronized (obj) {
						if (count % 3 != 2)
							try {
								obj.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						else {
							System.out.println("B");
							count++;
							obj.notifyAll();

						}

					}
				}
			}
		});
		Thread C = new Thread(new Runnable() {
			@Override
			//复写run方法，判断标记，如果符合就等待，
			//如果不符合执行打印代码，并使标记加1，唤醒其他所有在等待的线程
			public void run() {
				while (count <= 30) {
					synchronized (obj) {
						if (count % 3 != 0)
							try {
								obj.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						else {
							System.out.println("C");
							System.out.println("-------"+count/3);
							count++;
							obj.notifyAll();
						}

					}
				}
			}
		});
		A.start();
		B.start();
		C.start();
	}
}