黑马程序员--Java基础学习(多线程)第十二天

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Java基础学习(多线程)第十二天

一，线程间通信

线程间通信：其实就是多个线程在操作同一个资源，但是操作的动作不同。

class Res
{
	String name;
	String sex;
	boolean flag= false;

	public void set(String name,String sex)
	{
		if(flag)
		try{this.wait();}catch(Exception e){}
		this.name = name;
		this.sex = sex;
		flag=true;
		this.notify();
	}
	public void out()
	{
			if(!flag)
				try{this.wait();}catch(Exception e){}
			System.out.println(this.name+"....."+this.sex);
			this.flag=false;
			this.notify();	
	}
}
class Input implements Runnable
{
	private Res r;
	Input (Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x =0;
		while(true)
		{
			synchronized(r)
			{
				if(x==0)
					r.set("mike","man");
				else
					r.set("丽丽","女");
				x = (x+1)%2;
			}
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				r.out();
			}
		}
	}
}
class  InputOutputDemo
{
	public static void main(String[] args) 
	{
			Res r = new Res();

			Input in = new Input(r);
			Output out = new Output(r);

			Thread t1 = new Thread(in);
			Thread t2 = new Thread(out);

			t1.start();
			t2.start();
	}
}

代码中两个线程t1和t2分别对Res的对象数据进行操作。一个输入一个输出，形成线程间的IO通信。

二，线呈间通信-等待唤醒机制

等待的线程存在于线程池中。

wait();
notify();
notifyAll();
都使用在同步中，因为要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object中那？
因为这些方法在操作线程时，都必须要标识他们所操作线程持有的锁。
只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程唤醒。
也就是说，等待和唤醒必须是同一把锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object中。

三，线程间通信-JDK1.5升级版

JDK1.5中提供了多线程升级解决方案。
将同步Synchronized替换成实现Lock操作。
将Object中的wait，notify，notifyAll，替换了Condition对象。
该对象可以通过Lock锁进行获取。
在该示例中，实现了本方只唤醒对方的操作。

代码实例：

import java.util.concurrent.locks.*;

class ProduceConsumeDemo2 
{
	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(con);
		Thread t3= new Thread(pro);
		Thread t4 = new Thread(con);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
/*
JDK1.5中提供了多线程升级解决方案。
将同步Synchronized替换成实现Lock操作。
将Object中的wait，notify，notifyAll，替换了Condition对象。
该对象可以通过Lock锁进行获取。
在该示例中，实现了本方只唤醒对方的操作。

*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	private Lock lock = new ReentrantLock();
	
	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();

	public void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)//while保证唤醒后再进行判断
				condition_pro.await();
			this.name = name+"----"+count++;

			System.out.println(Thread.currentThread().getName()+"....生产者.."+this.name);
			flag=true;
			condition_con.signal();	
		}
		finally
		{
			lock.unlock();
		}
	}

	public void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println(Thread.currentThread().getName()+"....消费者......"+this.name);
			flag=false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();//释放锁的操作一定要执行。
		}
		
	}
}
class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch ( InterruptedException e)
			{
			}
			
		}
	}
}
class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}

四 ，停止线程

stop方法已经过时。

如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常都是循环结构。

只要控制住循环就可以让run方法结束，也就是线程结束。

特殊情况：
当线程处于了冻结状态。
就不会读取到标记，那么线程就不会结束。

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

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

五，守护线程

由setDaemon()方法将线程标记为守护线程也就是后台线程，该方法必须在启动线程前调用，

当正在运行的线程都是守护线程时，java虚拟机关闭。

六，join方法

等待线程终止，当A线程执行到B线程的join()方法时，A就会等待，等B线程都执行完。

代码：

import java.util.Date;
class StopThread implements Runnable
{
	private boolean flag = true;
	public /*synchronized*/ void run()
	{
		while(flag)
		{
			/*try
			{
				wait();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName()+"...Exception");
				flag = false;
			}*/
			System.out.println(Thread.currentThread().getName()+"...run");
			
		}
	}
	public void changeFlag()
	{
		flag=false;	
	}
}
class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();

		Thread t1=new Thread(st);
		Thread t2 = new Thread(st);

		t1.setDaemon(true);
		t2.setDaemon(true);
		
		t1.start();
		t2.start();

		int num = 0;
		//long time = new Date().getTime();//获取启动时的时间.
        //System.out.println(time);
		while(true)
		{
			if(num++ ==60)
			{
				//st.changeFlag();
			//t1.interrupt();
				break;
			}
				System.out.println(Thread.currentThread().getName()+"..."+num);

		}

	}
}