线程（生产者消费者问题）

Thread 随堂笔记

线程：一个程序里的不同执行路径。

线程的启动：

       方法一：实现Runnable接口（该接口只有一个方法 run）

       方法二：从Thread继承

Thread中的sleep方法：在哪个线程中调用Thread.sleep();哪个线程休息

Thread中的Join方法：在哪个线程中调用join();就把调用该方法的对象加入到该线程。

Thread中的yield方法：高风亮节把自己的线程先休息一会，让其它线程执行，Thread.yield

Thread中的priority：setPriority, getPriority

线程同步：

关键字：synchronized   锁定当前对象(在什么地方加锁呢，在线程共用的资源上加锁。)

DeadLock现象 ：有个两个对象o1,o2 ；两个线程t1,t2。线程t1锁住了o1，线程t1锁住                    了o2，当线程t1再锁住o2的时候它就能继续执行，当线程t2在锁住o1的时候它就 能继续执行。但是o2被t1锁住了，o1被t2锁住了。谁也得不到能让自己继续执行 的对象，所以就产生了死锁的现象。

wait与sleep的区别：

     线程wait时，线程进入等待状态，同时释放锁，如果没有人叫醒它，它就会一直在   wait。（注意，线程并没有死掉，而是wait）

     线程sleep时，线程进入睡眠状态，但是没有释放锁，这时显示不需要有人叫它就   会自己醒。

生产者消费者问题：介绍了wait()方法，notity()/notityAll()方法，的作用。

package com.liang.thread;

public class ProduerConsumer {
	public static void main(String[] args) {
		SyncStack ss = new SyncStack();
		Produer p = new Produer(ss);
		Consumer c = new Consumer(ss);
		Thread tp = new Thread(p);
		Thread tp2 = new Thread(p);
		Thread tc = new Thread(c);
		tp.start();
		tp2.start();
		tc.start();
		System.out.println(Thread.activeCount());  //返回当前线程的线程组中活动线程的数目
	}
}

class ManTou {
	private int id;
	
	public ManTou(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
}

class SyncStack {
	ManTou[] mts = new ManTou[6];
	int index = 0;
	public synchronized void push(ManTou mt) {   //把ManTou放进框子里
		while(index == mts.length) {
			try {
				this.wait();      //让当前线程进入等待状态
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();   //叫醒在当前对象上等待的线程（但是不能叫醒线程本身）
		mts[index++] = mt;
	}
	
	public synchronized ManTou pop() {   //把ManTou从框子里拿出来
		while(index == 0) {
			try {
				this.wait();    //让当前线程进入等待状态
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notify();   //叫醒在当前对象上等待的线程（但是不能叫醒线程本身）
		return mts[--index];
	}
	
}

class Produer implements Runnable{       //生产者
	private SyncStack ss;
	
	public Produer(SyncStack ss) {
		this.ss = ss;
	}
	
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			ManTou mt = new ManTou(i);
			ss.push(mt);
			System.out.println("生产了 ：" + mt.getId());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

class Consumer implements Runnable{   //消费者
	private SyncStack ss;
	
	public Consumer(SyncStack ss) {
		this.ss = ss;
	}

	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			 System.out.println("消费了 ：" + ss.pop().getId());
			 try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

 

 

Wait 和notify机制：wait/notify  机制是为了避免轮询带来的性能损失。 
为了说清道理，我们用“图书馆借书”这个经典例子来作解释。 一本书同时只能借给一个人。现在有一本书， 图书馆已经把这本书借了张三。 在简单的synchrnozed 同步机制下，李四如果想借，先要去图书馆查看书有没有还回 来。李四是个心急的人，他每天都去图书馆查；而张三看书看得慢，过了半个月才把书还回来，结果李四在这半个 月里全都白跑了，浪费了不少交通车费 
而如果使用wait/notify机制，李四就不用白忙了。他第一次去图书馆时发现书已借走，就回家静静等待(wait)；张 三把书还掉后，通知(notify)李四，李四去图书馆拿书即可。整个过程中，李四没有白跑，没浪费钱。 

    回到计算机世界： 
        书                                 --  临界资源，需互斥地访问 
        张三，李四                 --  两个竞争的线程 
        坐车去图书馆查书     --  轮询 
        车费                             --  CPU空间 
        等待                             --  wait 
        通知下一个借书者     --  notify 
 
    也就是说，若使用简单的synchonized机制实现互斥，会导致线程主动发起轮询，若N次轮询没有成功，就产生了N次的CPU空间浪费；如果加上了 wait/notify机制，就可以避免这些无谓的轮询，节省CPU的消耗。

 

补充：

wait与notify是java同步机制中重要的组成部分。结合与synchronized关键字使用，可以建立很多优秀的同步模型。
     synchronized(this){}等价与public synchronized void method(){.....}
     同步分为类级别和对象级别，分别对应着类锁和对象锁。类锁是每个类只有一个，如果static的方法被synchronized关键字修饰，则在这个方法被执行前必须获得类锁；对象锁类同。(static synchronized是类级别的,非static的synchronized和synchronized块都是对象级别的,即作用在同一new出来的对象上)
     首先，调用一个Object的wait与notify/notifyAll的时候，必须保证调用代码对该Object是同步的，也就是说必须在作用等同于synchronized(obj){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法，否则就会报错：
     java.lang.IllegalMonitorStateException: current thread not owner
     在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。
     所以，notify与notifyAll没有太多的区别，只是notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁，只要是在synchronied块中的代码，没有对象锁是寸步难行的。其实唤醒一个线程就是重新允许这个线程去获得对象锁并向下运行。       顺便说一下notifyall，虽然是对每个wait的对象都调用一次notify，但是这个还是有顺序的，每个对象都保存这一个等待对象链，调用的顺序就是这个链的顺序。其实启动等待对象链中各个线程的也是一个线程，在具体应用的时候，需要注意一下。