黑马程序员---Java基础--12天(多线程)

---------------------- android培训、java培训、期待与您交流！ ---------------------

1.多线程(线程间通信-示例代码)

2.多线程(线程间通信-解决安全问题)

3.多线程(线程间通信-等待唤醒机制)

/*
线程间通信:
其实就是多个线程在操作一个资源.
但是操作的动作不同.
*/
class Res
{
	String name;
	String sex;
	boolean flag = false;
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x = 0;
		while(true)
		{
			synchronized(r)
			{
				if(r.flag)
					try{r.wait();}catch(Exception e){}
				if(x==0)
				{
					r.name = "mike";
					r.sex = "man";
				}
				else
				{
					r.name = "丽丽";
					r.sex = "女";
				}
				x = (x+1)%2;
				r.flag = true;
				r.notify();
			}
		}
	}


}
class Output implements Runnable
{
	private Res r;
	OutPut(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				if(!r.flag)
					try{r.wait();}catch(Exception e){}
				System.out.println(r.name+"..."+r.sex);
				r.flag = false;
				r.notify();
			}
		}
	}
}
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.strat();
	}
}
//notifyAll();


/*
wait();
notify();
notifyAll();


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


为什么这些操作线程的方法要定义Object类中呢?


因为这些方法在操作同步中线程时,都比需要标识他们所操作此案成只有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒.


也就是说,等待和唤醒必须是同一个锁.


而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object类中.
*/

4.多线程(线程间通信-代码优化)

class Res
{
	String name;
	String sex;
	boolean flag = false;
	public synchronized 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 synchronized void out()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"..."+sex);
		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)
		{
			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)
		{
			r.out();
		}
	}
}
class  
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		new Thread(new Input(r).start());
		new Thread(new Output(r).start());
	}
}

5.多线程(生产者消费者)

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(con);
		Thread t4 = new Thread(con);


		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
/*
对于多个生产者和消费者.
为什么要定义while判断标记?
原因:让被唤醒的线程再一次判断标记.


为什么定义notifyAll(),
因为需要唤醒对方线程.
因为只用notify(),容易出现只唤醒本方线程的情况,
导致程序中所有线程都等待.
*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
				// t1  t2
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name+"--"+count++;
		System.out.println(Thread.currentThread().getName()+"...生产者"+this.name);
		flag = true;
		this.notifyAll();
	}
	//t3 t4
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者"+this.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)
	{
		while(true)
		{
			res.out();
		}


	}
}

6.多线程(生产者消费者JDK1.5升级版)

i

mport java.util.concurrent.locks.*;
class  ProducerConsumerDemo2
{
	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(con);
		Thread t4 = new Thread(con);


		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
/*
JDK1.5中提供了多线程升级解决方案.
将同步Synchronized替换成现实Lock操作.
将Object中wait(),notify(),notifyAll(),替换成Condition对象.
该对象可以Lock锁进行获取.


该实例中,实现了奔放只唤醒对方操作.


Lock :替换了synchronized
lock
unlock
newCondition()


Condition:替代了Object wait notify notifyAll


await()
signal()
signalAll();
*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	private Lock lock = new ReentrantLock();
	
	private Condition condition_pro = new lock.newCondition();
	private Condition condition_con = new lock.newCondition();
	
	public void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();//t1 t2
			this.name = name+"----"+count++;
			
			System.out.println(Thread.currentThread().getName()+"....生产者"+this.name);
			flag = true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行.
		}


	}
	// t3   t4
	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)
			{
			}
		}
	}
}

7.多线程(停止线程)

8.多线程(守护线程)

/*
stop方法已经过时。


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


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




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


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


Thread类提供该方法 interrupt();






*/
class StopThread implements Runnable
{
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			
			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;


		while(true)
		{
			if(num++ == 60)
			{
				//st.changeFlag();
				//t1.interrupt();
				//t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"......."+num);
		}
		System.out.println("over");
	}
}

9.多线程(Join方法)

/*
join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。


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




*/

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.youkuaiyun.com/heima