黑马程序员_java基础多线程

------ <a href="http://www.itheima.com" target="blank">Windows Phone 7手机开发</a>、<a href="http://www.itheima.com" target="blank">.Net培训</a>、期待与您交流！ -------

/*多线程部分学习心得*/
//懒汉式 考点：1延迟加载2双重判断减少判断次数3synchronized的参数是类的字节码对象,非静态方法才使用默认的this锁
class single {
	
	private static single getInstance()
	{
		if(s==null)
		{
			synchronized(single.class)
			{
				if(s==null)
					s=new single();
			}
		}return s;
	}
}
//写个死锁程序 考点：同步中嵌套同步，锁却不同。
class Ticket implements Runnable
{
	private int tick = 100;
	Object obj =new Object;
	boolean flag = true;
	public void run()
	{
		if(flag)
		{
			while(true)
		{
				synchronized(obj)
				{
					show();
				}
		}
	}
		else 
			while(true)
				show();
	}
	public synchronized void show()
	{
		synchronized(obj)
		{
			if(tick>0)
			{
				try{Thread.sleep(10);}
				catch(Exception e){}
				System.out.println(Thread.currentThread().getName()+"...sale: "+ tick--);
			}
		}
	}
}
class DeadLockDemo
{
	public static void main(String[] args)
	{
		//构建新对象
		Ticket t = new Ticket();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try{Thread.sleep(10);}
		catch(Exception e){}
		t.flag = false;
		t2.start();
	}
}
//线程间通讯：其实就是多个线程在操作同一个资源，但是操作的动作不同。
/*
 * 思路：车一存在就有煤，所以车初始化就定义煤。有可能资源属性不完整就切换了进程。线程实现同步
 * 的前题是1多（两）个线程共同操作资源的代码块要加上synchronized;2用的是同一把锁。
 * 等待唤醒机制：为了满足输入一个取出一个，在资源中添加一个标记，判断为ture时，就冻结同时唤醒另一线程。
 * 等待线程都存在线程池中的线程，notify通常唤醒第一个等待的线程。wait,notify,notifyAll都使用在同步
 * 中，因为要对持有监视器（锁）的线程操作。
 * 数据私有，提供方法。
 * 生产者消费者,while循环，notifyAll
 * 
 * 步骤
 * 1 描述资源
 * 2 描述输入的run
 * 3 描述输出的run
 * 
 * 
 * */
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(pro);
		Thread t4 = new Thread(pro);
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
	//资源
class Resource {
	private String name;
	private int count = 1;
	private boolean flag = false;
	
//方法要有自己的参数
public synchronized  void set(String name) {
	
	while(flag)
	//是真，就等待,注意格式
	try{this.wait();}
	catch(Exception e){}
	//判断是否执行
	//带有编号地赋值
	//首先，写出构造方法，带线程名称更直观，产品名称
	this.name = name+"--"+count++;
	//力求代码简单
	System.out.println(Thread.currentThread().getName()+"...生产者..."+name);
	//唤醒程序
	flag =true;
	this.notifyAll();
}
			
//生产者

//消费者没有默认参数
public synchronized void out() {
		while(!flag)
		//是假，就等待,注意格式
		try{this.wait();}
		catch(Exception e){}
		//判断是否执行
		//带有编号地赋值
		//首先，写出构造方法，带线程名称更直观，产品名称
		//力求代码简单
		System.out.println(Thread.currentThread().getName()+"...消费者....."+name);
		//唤醒程序
		flag =false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;
	
	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{//在不断设置值，类.方法名
			res.set("+商品+");
		}
	}
}
class Consumer implements Runnable
{
	private Resource res;
	
	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{//消费者在不断消费
			res.out();
		}
	}
}

/**当没有指定的方法让冻结的线程恢复到运行状态时，
 * 这时需要对冻结进行清除。强制让线程恢复到运行状态。
 * Thread类提供了interrupt方法。
 * join抢夺cpu执行权。它结束了，主线程才恢复到执行状态。
 * join可临时加入线程执行。
 * t1.setPriority(Thread.MAX_PRIORITY);
 * Thread.yield();可稍微减缓线程的运行，具有平均执行的作用。
 * 单独封装成一个线程：独立运算，相互不相关，提高效率的方法。
  */