多线程知识点3

如果对一块共享数据，多个线程做不同的操作，有读有写，就有必要进行线程通讯处理，以便提高效率。

一、线程通讯：

1、线程通讯的概念：
线程通讯指的是多个线程通过消息传递实现相互牵制，相互调度，即线程间的相互作用。


2、Java线程通讯的实现：
Java代码中基于对共享数据进行“wait()、notify()、notifyAll()”来实现多个线程的通讯。
 
经典例子：生产者和消费者的问题。
 
1）、Warehouse.java

<span style="font-size:18px;">import java.util.ArrayList;
import java.util.List;

/**
 * 仓库类，用储存商品，联系生产者和消费者
 * @author hanwen
 *
 */
public class Warehouse {
	
	//定义一个集合，用来存储生产的产品
	private List<String> products=new ArrayList<String>();
	
	
	/**
	 * 生产者生产商品，存储到仓库里
	 */
	public void addproduct(String stringname){
		products.add(stringname);//想仓库里面添加产品
	}
	
	/**
	 * 消费者消费商品
	 */
	public String getProduct(){
		//判断仓库是不是为空
		if(!products.isEmpty()){
			//从仓库中取产品，返回给消费者
			String stringname=products.remove(0);
			return stringname;
		}else{
			System.out.println("仓库为空，请及时生产产品...");
			return "";
		}
	}
	
	/**
	 * 获取库存余量
	 * 
	 * @return
	 */
	public int getSize(){
		//返回库存余量
		return products.size();
	}	
}</span>

2）、CustomerThread.java

<span style="font-size:18px;">/**
 * 消费者线程类
 * 
 * @author Administrator
 *
 */
public class CustomerThread implements Runnable {
	// 属性
	private Warehouse wh;      // 仓库对象
	private String name;       // 消费者姓名

	// 构造函数传递参数
	public CustomerThread(Warehouse wh, String name) {
		super();
		this.wh = wh;
		this.name = name;
	}

	// 消费产品
	@Override
	public void run() {

		while (true) {
			synchronized (wh) {
				if (wh.getSize() == 0) {
					try {
					    System.out.println("仓库为空，消费者" + name + "进入等待状态........");
						wh.wait();
						System.out.println("线程等待结束，重新启动");
						
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else if (wh.getSize() > 0) {
					// 取走商品，
					String stringname = wh.getProduct();
					System.out.println("消费者" + name + "取走了产品" + stringname);
				}
			}
			try {
				Thread.sleep(1500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}</span>

3）、ProductThread.java

<span style="font-size:18px;">import java.util.Random;

public class ProductThread implements Runnable {

	// 定义一个仓库对象
	private Warehouse wh;

	// 有参数的构造方法
	public ProductThread(Warehouse wh) {

		super();
		this.wh = wh;
	}

	/**
	 * 开始生产产品
	 */
	@Override
	public void run() {
		while (true) {
			// 自动的随机产生产品
			String stringname = "p" + (new Random()).nextInt(1000);

			synchronized (wh) {
				// 把产品放进仓库
				wh.addproduct(stringname);
				// 提示信息
				System.out.println("仓库里面已经存入商品" + stringname);
				//唤醒线程，让他继续执行
				//wh.notify();
				wh.notifyAll();
			}
			try {
				// 睡一会
				Thread.sleep(1500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}</span>

4）、TestDemo.java

<span style="font-size:18px;">/**
 * 测试类
 * @author Administrator
 *
 */
public class TestDemo {

	public static void main(String[] args) {
	 
	//实例化仓库对象
		Warehouse wh=new Warehouse();
		
		//实例化生产者对象
		ProductThread pt=new ProductThread(wh);
		//实例化消费者对象
		CustomerThread ct=new CustomerThread(wh,"小明");
		CustomerThread ct1=new CustomerThread(wh,"小花");
		CustomerThread ct2=new CustomerThread(wh,"小灰灰");
		CustomerThread ct3=new CustomerThread(wh,"小飞飞");
		
		//建线程类进行包装
		Thread t=new Thread(pt);
		Thread t2=new Thread(ct);
		Thread t3=new Thread(ct1);
		Thread t4=new Thread(ct2);
		Thread t5=new Thread(ct3);
		
		//启动线程
		t.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
	}
}</span>

3、wait()、notify()、notifyAll() 方法：

   ①、final void notify()  唤醒在此对象监视器上等待的单个线程
   ②、final void notifyAll() 唤醒在此对象监视器上等待的所有线程
   ③、final void wait() throws InterruptedException 导致当前的线程等待，直到其他线程调用此对象的 notify()
          方法或 notifyAll() 方法
   ④、final void wait(long timeout) throws InterruptedException 导致当前的线程等待，直到其他线程调用此对
          象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
   ⑤、final void wait(long timeout, int nanos) throws InterruptedException 导致当前的线程等待，直到其他

          线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实

          际时间量。

   ⑥、wait() 和 notify() 方法(包括上述的所有方法，下同) 都是 Object 类的最终方法，所以每个类默认都拥有该方                  法。 为确保 wait() 和 notify() 的功能，在执行之前必须要先获得互斥锁，即一定要和 synchronized 一起使用。
           如 synchronized 的锁对象是 obj 的话，wait 和 notify 正确的使用方法是obj.wait()和obj.notify()。



4、sleep() 和 wait() 的区别：


                 sleep()                       wait()
            
属性           Thread的静态方法                            Object的方法


作用             让本线程进入睡眠状态                     让本线程进入等待状态


是否释放同步锁      不会释放同步所                                会释放同步所




5、线程死锁：


   ①、线程死锁指的两个线程互相持有对方依赖的共享资源，造成都无限阻塞。
   ②、导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。
   ③、解决死锁的方法：
                     让线程持有独立的资源。
               尽量不采用嵌套的 synchronized 语句。
    
6、线程状态转换：


   线程状态介绍
    1）、新建状态（New）：使用 new 关键字创建线程对象，仅仅被分配了内存；
2）、可运行状态（Runnable）：线程具备获得CPU时间片的能力。线程进入可运行状态的情况如下：

         ①、线程 start() 方法被调用；
         ②、当前线程 sleep()、其它线程 join() 结束、等待用户输入完毕；
         ③、某个线程取得对象锁；

         ④、当前线程时间片用完了，调用当前线程的 yield() 方法。

 3）、运行状态（Running）：执行 run 方法，此时线程获得CPU的时间片；

         4）、阻塞状态（Blocked）：线程由于某些事件放弃CPU使用权，暂停运行。直到线程重新进入可运行

                  状态，才有机会转到运行状态。阻塞状态分为如下几种：

      
   ①、同步阻塞 – 线程获得同步锁，若被别的线程占用，线程放入锁池队列中。
   ②、等待阻塞 – 线程执行 wait() 方法，线程放入等待队列中。

   ③、其它阻塞 – 线程执行 sleep() 或 join() 或发出 I/O 请求。

   5）、死亡状态（Dead）：run、main() 方法执行结束，或者因异常退出了 run() 方法，线程进入死亡状

                  态，不可再次复生。