黑马程序员--- 学习笔记(第十二天

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
多线程之间的通信
其实就是多线程在操作同一资源,但是操作的动作不同

/*
多线程之间的通信

一个线程负责写,一个线程负责读


*/
class Demo 
{
	public static void main(String[] args) 
	{
		 Resource r=new Resource();
		 new Thread(new WriterThread(r)).start();
		 new Thread(new ReaderThread(r)).start();
	}
}
/*操作共同的资源*/
class Resource
{
   private String name;
   private String sex;
   private boolean flag=true;
   public void setFlag(boolean flag){
   		this.flag=flag;
   }
   public synchronized void setInfo(String name,String sex){
	   while(flag){ //每次都判断标记
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
			}
	   }
		this.name=name;
		this.sex=sex;
		flag=true;
		notifyAll();
   }
   public synchronized void getInfo(){
	    while(!flag){
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
			}
	   }
		System.out.println(name+"-----"+sex);
		flag=false;
		notifyAll();
   }

}
/*写入线程*/
class WriterThread implements Runnable
{
	private Resource r;
	public WriterThread(Resource r){
		this.r=r;			
	}
	public void run(){
		  int i=0;
		while(true){
			if(i%2==0){
				r.setInfo("track","man");
			}else{
				r.setInfo("赖海娟","女");
			}
			i++;
		}
	}

}
/*读取线程*/
class ReaderThread  implements Runnable
{
   private Resource r;
	public ReaderThread(Resource r){
		this.r=r;			
	}
	public void run(){
		while(true){
			r.getInfo();
		}
	}
}

wait();
notify();
notifyAll();
都使用在同步中,因为要对持有监视器的线程操作,所以都要使用在
同步中,因为只有同步才具有监视器


为什么这些操作线程方法要定义在Object类中呢?
因为这些方法在操作同步中的线程,都必须要在标识他们的操作线程只有
的锁,只有同一个锁上的被等待线程,可以被同一个锁notify()唤醒,不可以
对不同锁中的线程进行唤醒,也就是说等待和唤醒是同一个锁.
而锁可以使任意对象,所以可以被任意对象调用的方法定义在Object中

一对一生产者,消费者:

/*
生产者,消费者

*/
class Demo1 
{
	public static void main(String[] args) 
	{
		 Resource r=new Resource();
		 new Thread(new Producer(r)).start();
		  new Thread(new Consumer(r)).start();
	}
}
/*共同所操作的资源*/
class Resource
{
	private String ware;
	private int count=1;
	private boolean b=false;
	public  String getWare(){
		return ware;
	}
	public synchronized  void proWare(String ware){
		while(b)
		try
		{
			wait();
		}
		catch (InterruptedException e)
		{
		}
		this.ware=ware+":::"+count++;
		b=true;
		notifyAll();
	}
	public synchronized void conWare(){
		while(!b)
		try
		{
			wait();
		}
		catch (InterruptedException e)
		{
		}
		 System.out.println("消费--------------"+ware);
		 b=false;
		 notifyAll();
	}
}
/*生产者*/
class Producer implements Runnable
{
	private Resource r;
	public Producer(Resource r){
		this.r=r;
	}
	public void run(){
		while(true){
		r.proWare("商品");
		System.out.println("生产-----------"+r.getWare());
		}
	}
}
/*消费者*/
class Consumer implements Runnable
{	
	private Resource r;
	public Consumer(Resource r){
		this.r=r;
	}
	public void run(){
		while(true)
			r.conWare();
	}
}

对于多个生产者和消费者
为什么要定义while判断标记?
原因:让被唤醒的线程再一次判断标记

/*
生产者 消费者 

使用JDK1.5提供的解决方案

只唤醒对方的等待线程
*/
import java.util.concurrent.locks.*;
class Demo2 
{
	public static void main(String[] args) 
	{
		 Resource r=new Resource();

		 /*两个生产者*/
		 new Thread(new Producer(r)).start();
		 new Thread(new Producer(r)).start();

		    /*两个消费者*/
		  new Thread(new Consumer(r)).start();
		  new Thread(new Consumer(r)).start();
	}
}
/*共同所操作的资源*/
class Resource
{
	private String ware;
	private int count=1;
	private boolean b=false;
	 private Lock lock=new ReentrantLock();
	 private Condition con_pro=lock.newCondition();
	 private Condition con_con=lock.newCondition();
	public  String getWare(){
		return ware;
	}
	public  void proWare(String ware)throws InterruptedException{
		lock.lock(); //	获取锁

		while(b)
			try
			{
				con_pro.await(); //等待
			}
			finally
			{
				lock.unlock();//释放锁
			}
		this.ware=ware+":::"+count++;
		b=true;	
		con_con.signalAll();//唤醒对方的等待线程
	}
	public  void conWare()throws InterruptedException{
		lock.lock();
		while(!b)
		try
		{
			con_con.await();
		}
		finally
		{
			lock.unlock();
		}
		 System.out.println(Thread.currentThread().getName()+"消费--------------"+ware);
		 b=false;
		 con_pro.signalAll();
	}
}
/*生产者*/
class Producer implements Runnable
{
	private Resource r;
	public Producer(Resource r){
		this.r=r;
	}
	public void run(){
		while(true){
			try
			{
				r.proWare("商品");
				System.out.println(Thread.currentThread().getName()+"生产-----------"+r.getWare());
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
}
/*消费者*/
class Consumer implements Runnable
{	
	private Resource r;
	public Consumer(Resource r){
		this.r=r;
	}
	public void run(){
		while(true){
				try{
					
					r.conWare();

				}
				catch (InterruptedException e)
				{
					e.printStackTrace();
				}
		}
	}
}

为什么定义notifyAll?
因为需要唤醒的对方线程.因为只用notify,容易出现只唤醒本方线程的
情况,导致程序中的所有程序都在等待.


如何只唤醒对方呢?
需要导包:java.util.concurrent.locks;
JDK1.5中提供了多线程升级解决方法.将同步synchronized替换成显示的Lock
操作. 将Object中的wait,notify,notifyAll替换成Condition对象,该对象
可以通过Lock锁进行获取?
 Lock lock=new ReentrantLock();
 Condition con=lock.newCondition();


在该示例中实现本方只唤醒对方操作?




停止线程
stop方法已经过时?
如何停止线程?只有一种方法就是run方法结束

/*
如何停止线程  清除线程的冻结状态interrupt
*/
class Demo3 
{
	public static void main(String[] args) 
	{
		Test t=new Test();
		Thread tt=new Thread(t);
		tt.start();
		try
		{
			Thread.sleep(5000);
			tt.interrupt();	//5秒清除线程的冻结状态,重新开始执行
		}
		catch (Exception e)
		{
		}
	}
}
class Test implements Runnable
{
	public synchronized void run(){
		for (int i=0;i<100 ;i++ )
		{
			System.out.println(Thread.currentThread().getName()+"::"+i);

			//假如出现wait,则线程冻结  需要清除该状态才可以继续执行
			if(i==10)
				try
				{
					wait();
				}
				catch (InterruptedException  e)
				{
					e.printStackTrace();
				}
		}
	}
	
}

开启多线程运行,运行代码通常是循环结构,只要控制住循环,就可以 
让run方法结束.也就是线程结束


特殊情况,当线程处于冻结状态,就不会读到标记,那么线程就不会结束


当没有指定的方式让冻结的线程恢复到运行状态,这时需要对冻结进行清除
,强制性制止过程恢复到运行状态中来,这样就可以操作标记让线程结束


Thread类提供了该方法 interrupt();


守护线程:
setDaemon();
将该线程标志为守护线程,或用户线程就是后台线程
必须在启动线程前调用,主线程运行完毕,守护线程机会结束.jvm虚拟机结束


join();
当A线程执行到了B线程的join方法时,就会等待,等b线程执行完毕.
A才会执行


join可以用来临时加入线程执行


toString();
返回线程名称,线程优先级,线程组


ThreadGroup 线程组几乎用不上,就是谁调用该线程,它就属于哪个组,开发不常见


setPriority();//默认优先级是5


MAX_PRIORITY; //最高优先级10
MIN_PRIORITY; //最低优先级1
NORM_PRIORITY;//默认优先级5


yield(); //暂停当前运行线程


当某些代码需要被同时执行时,就等着成线程对象.

开发通常使用Thread的匿名子类或者Runnable的匿名子类

/*
setDaemon守护线程 
join临时加入线程  
toString//返回线程名称,优先级,线程组
setPriority//设置优先级
yield//暂停线程运行
*/
class Demo4 
{
	public static void main(String[] args) 
	{
		
		Thread t1=new Thread(){
			public void run(){
				for (int i=1;i<=20 ;i++ )
				{
					System.out.println(Thread.currentThread().toString()+":::"+i);
					/*
					//当设置为守护线程时,即使wait 主线程运行完 主线程就会结束
					if(i==10){
						try
						{
							wait();
						}
						catch (InterruptedException e)
						{
						}
					}
					*/
				}
			}
		};


		Runnable r=new Runnable(){
			public void run(){
				for (int i=1;i<=20 ;i++ )
				{
					System.out.println(Thread.currentThread().toString()+":::"+i);
					/*
					//当设置为守护线程时,即使wait 主线程运行完 主线程就会结束
					if(i==10){
						try
						{
							wait();
						}
						catch (InterruptedException e)
						{
						}
					}
					*/
				}
			}
		};
		Thread t2=new Thread(r);
		//t1.setPriority(Thread.MAX_PRIORITY);//设置t1的优先级为10 最大
	
		//t1.setDaemon(true); //设置为守护线程
		//t2.setDaemon(true);
		t1.start();
		t2.start();
		
		t1.yield();	//暂停对当前运行线程 本人经测试 看不出啥  是不是单核电脑的忧桑?
		//主线程
	
		for (int i=1;i<=50 ;i++ )
				{
					System.out.println(Thread.currentThread().toString()+":::"+i);
				}
	

	   /*
	   //join();//用来临时加入线程
	   try
	   {
				t1.join();// 本人经测试 看不出啥  是不是单核电脑的忧桑?
	   }
	   catch (Exception e)
	   {
	   }
	   */
	}
}

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————